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

server handshake gui

Browse Source
This commit is contained in:
wikano
2026-01-02 23:21:50 +01:00
parent 1914c68c9f
commit 74f30f2c7f
5 changed files with 91 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,7 +13,7 @@ use crate::{
registration::{
get_socket_address, parse_addresses, register_ip_addresses, register_with_the_server,
},
server_communication::get_peer_list,
server_communication::{generate_id, get_peer_list},
};
use std::sync::{Arc, Mutex};
use std::{
@@ -55,6 +55,27 @@ impl P2PSharedData {
pub fn cryptopair(&self) -> Arc<CryptographicSignature> {
self.shared_cryptopair.clone()
}
pub fn messages_list(&self) -> Arc<Mutex<HashMap<i32, EventType>>> {
self.shared_messageslist.clone()
}
pub fn senders(&self) -> Arc<MultipleSenders> {
self.shared_senders.clone()
}
pub fn socket_ref(&self) -> &UdpSocket {
&*self.shared_socket
}
pub fn cryptopair_ref(&self) -> &CryptographicSignature {
&*self.shared_cryptopair
}
pub fn messages_list_ref(&self) -> &Mutex<HashMap<i32, EventType>> {
&*self.shared_messageslist
}
pub fn senders_ref(&self) -> &MultipleSenders {
&*self.shared_senders
}
pub fn add_message(&self, id: i32, evt: EventType) {
let mut map = self.shared_messageslist.lock().unwrap();
@@ -65,7 +86,7 @@ impl P2PSharedData {
/// Messages sent to the Network thread by the GUI.
pub enum NetworkCommand {
ConnectToServerPut(String, String), // ServerIP
ServerHandshake(String), // ServerName
ServerHandshake(String, String), // ServerName
FetchPeerList(String), // ServerIP
RegisterAsPeer(String),
Ping(),
@@ -128,48 +149,55 @@ pub fn start_p2p_executor(
// Check for commands from the GUI
if let Ok(cmd) = cmd_rx.try_recv() {
match cmd {
NetworkCommand::ServerHandshake(username) => {
let server_addr_query = get_socket_address(username);
NetworkCommand::ServerHandshake(username, ip) => {
if let Some(sd) = shared_data.as_ref() {
println!("username:{}, ip:{}", username, ip);
let server_addr_query = get_socket_address(username, ip);
match server_addr_query.await {
Ok(sockaddr_bytes) => {
match String::from_utf8(sockaddr_bytes.to_vec()) {
Ok(s) => {
let addresses = parse_addresses(&s);
if let Some(first) = addresses.first() {
// first: &SocketAddr
/*start_receving_thread(
&shared_socket,
&shared_messageslist,
&shared_cryptopair,
*first, // copie le SocketAddr (implémente Copy pour SocketAddr)
&shared_senders,
);
register_ip_addresses(
&shared_cryptopair,
first.to_string(),
&shared_senders,
&shared_messageslist,
545,
);*/
match server_addr_query.await {
Ok(sockaddr_bytes) => {
match String::from_utf8(sockaddr_bytes.to_vec()) {
Ok(s) => {
let addresses = parse_addresses(&s);
if let Some(first) = addresses.first() {
// first: &SocketAddr
start_receving_thread(
sd,
*first, // copie le SocketAddr (implémente Copy pour SocketAddr)
);
register_ip_addresses(
sd.cryptopair_ref(),
first.to_string(),
sd.senders_ref(),
sd.messages_list_ref(),
generate_id(),
);
//let res = event_tx.send(NetworkEvent::Connected());
} else {
let res = event_tx
.send(NetworkEvent::ConnectedHandshake());
} else {
//let res = event_tx.send(NetworkEvent::Error());
eprintln!(
"no valid socket addresses found in: {}",
s
);
}
}
Err(e) => {
//let res = event_tx.send(NetworkEvent::Error());
eprintln!("no valid socket addresses found in: {}", s);
eprintln!(
"invalid UTF-8 in socket address bytes: {}",
e
);
}
}
Err(e) => {
//let res = event_tx.send(NetworkEvent::Error());
eprintln!("invalid UTF-8 in socket address bytes: {}", e);
}
}
}
Err(e) => {
let mut err_msg =
String::from("failed to retrieve socket address:");
err_msg += &e.to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg));
Err(e) => {
let mut err_msg =
String::from("failed to retrieve socket address:");
err_msg += &e.to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg));
}
}
}
}

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

@@ -1,3 +1,4 @@
use crate::P2PSharedData;
use crate::cryptographic_signature::CryptographicSignature;
use crate::message_handling::EventType;
use crate::message_handling::handle_recevied_message;
@@ -111,17 +112,11 @@ impl MultipleSenders {
});
}*/
pub fn start_receving_thread(
socket: &Arc<UdpSocket>,
messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
crypto_pair: &Arc<CryptographicSignature>,
socket_addr: SocketAddr,
senders: &Arc<MultipleSenders>,
) {
let sock_clone = Arc::clone(socket);
let cryptopair_clone = Arc::clone(crypto_pair);
let senders_clone = Arc::clone(senders);
let messages_clone = Arc::clone(messages_list);
pub fn start_receving_thread(shared_data: &P2PSharedData, socket_addr: SocketAddr) {
let sock_clone = shared_data.socket();
let cryptopair_clone = shared_data.cryptopair();
let senders_clone = shared_data.senders();
let messages_clone = shared_data.messages_list();
thread::spawn(move || {
let mut buf = [0u8; 1024];
loop {

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

@@ -33,9 +33,9 @@ pub async fn register_with_the_server(
/// sends a get request to the server to get the socket address of the given peer
///
pub async fn get_socket_address(username: String) -> Result<Bytes, reqwest::Error> {
pub async fn get_socket_address(username: String, ip: String) -> Result<Bytes, reqwest::Error> {
let client = reqwest::Client::new();
let uri = format!("https://jch.irif.fr:8443/peers/{}/addresses", username);
let uri = format!("{}/peers/{}/addresses", ip, username);
let res = client.get(uri).send().await?;
if res.status().is_success() {
println!("Successfully retreived the addresses.");
@@ -70,7 +70,7 @@ pub fn register_ip_addresses(
crypto_pair: &CryptographicSignature,
server_uri: String,
senders: &MultipleSenders,
messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
messages_list: &Mutex<HashMap<i32, EventType>>,
id: i32,
) {
let username_size = crypto_pair.username.len();
@@ -92,6 +92,7 @@ pub fn register_ip_addresses(
list.insert(id, EventType::ServerHelloReply);
}
}
println!("message sent: {}", &id);
// 3. Perform the insertion
/*let mut buf = [0u8; 1024];
socket.recv_from(&mut buf).expect("receive failed");

5
client-network/src/server_communication.rs
View File

@@ -1,4 +1,5 @@
use bytes::Bytes;
use rand::Rng;
pub async fn get_peer_list(server_address: String) -> Result<Bytes, reqwest::Error> {
let client = reqwest::Client::new();
@@ -15,3 +16,7 @@ pub async fn get_peer_list(server_address: String) -> Result<Bytes, reqwest::Err
let body: Bytes = res.bytes().await?;
Ok(body)
}
pub fn generate_id() -> i32 {
rand::rng().random_range(0..i32::MAX)
}