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

13
client-gui/src/gui_app.rs
View File

@@ -350,13 +350,20 @@ impl eframe::App for P2PClientApp {
selectable.context_menu(|ui| { selectable.context_menu(|ui| {
// ... action // ... action
match self.server_status { match self.server_status {
ServerStatus::Connected => {} ServerStatus::Connected => {
_ => {
if ui if ui
.button("Utiliser le peer en tant que serveur") .button("Utiliser le peer en tant que serveur")
.clicked() .clicked()
{} {
let res = self.network_cmd_tx.send(
NetworkCommand::ServerHandshake(
peer.to_string(),
self.connected_address.clone(),
),
);
}
} }
_ => {}
} }
if ui.button("Infos").clicked() { if ui.button("Infos").clicked() {
// action 3 // action 3

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

@@ -13,7 +13,7 @@ use crate::{
registration::{ registration::{
get_socket_address, parse_addresses, register_ip_addresses, register_with_the_server, 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::sync::{Arc, Mutex};
use std::{ use std::{
@@ -55,6 +55,27 @@ impl P2PSharedData {
pub fn cryptopair(&self) -> Arc<CryptographicSignature> { pub fn cryptopair(&self) -> Arc<CryptographicSignature> {
self.shared_cryptopair.clone() 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) { pub fn add_message(&self, id: i32, evt: EventType) {
let mut map = self.shared_messageslist.lock().unwrap(); let mut map = self.shared_messageslist.lock().unwrap();
@@ -65,7 +86,7 @@ impl P2PSharedData {
/// Messages sent to the Network thread by the GUI. /// Messages sent to the Network thread by the GUI.
pub enum NetworkCommand { pub enum NetworkCommand {
ConnectToServerPut(String, String), // ServerIP ConnectToServerPut(String, String), // ServerIP
ServerHandshake(String), // ServerName ServerHandshake(String, String), // ServerName
FetchPeerList(String), // ServerIP FetchPeerList(String), // ServerIP
RegisterAsPeer(String), RegisterAsPeer(String),
Ping(), Ping(),
@@ -128,48 +149,55 @@ pub fn start_p2p_executor(
// Check for commands from the GUI // Check for commands from the GUI
if let Ok(cmd) = cmd_rx.try_recv() { if let Ok(cmd) = cmd_rx.try_recv() {
match cmd { match cmd {
NetworkCommand::ServerHandshake(username) => { NetworkCommand::ServerHandshake(username, ip) => {
let server_addr_query = get_socket_address(username); 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 { match server_addr_query.await {
Ok(sockaddr_bytes) => { Ok(sockaddr_bytes) => {
match String::from_utf8(sockaddr_bytes.to_vec()) { match String::from_utf8(sockaddr_bytes.to_vec()) {
Ok(s) => { Ok(s) => {
let addresses = parse_addresses(&s); let addresses = parse_addresses(&s);
if let Some(first) = addresses.first() { if let Some(first) = addresses.first() {
// first: &SocketAddr // first: &SocketAddr
/*start_receving_thread( start_receving_thread(
&shared_socket, sd,
&shared_messageslist, *first, // copie le SocketAddr (implémente Copy pour SocketAddr)
&shared_cryptopair, );
*first, // copie le SocketAddr (implémente Copy pour SocketAddr) register_ip_addresses(
&shared_senders, sd.cryptopair_ref(),
); first.to_string(),
register_ip_addresses( sd.senders_ref(),
&shared_cryptopair, sd.messages_list_ref(),
first.to_string(), generate_id(),
&shared_senders, );
&shared_messageslist,
545,
);*/
//let res = event_tx.send(NetworkEvent::Connected()); let res = event_tx
} else { .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()); //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) => {
Err(e) => { let mut err_msg =
let mut err_msg = String::from("failed to retrieve socket address:");
String::from("failed to retrieve socket address:"); err_msg += &e.to_string();
err_msg += &e.to_string(); let res = event_tx.send(NetworkEvent::Error(err_msg));
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::cryptographic_signature::CryptographicSignature;
use crate::message_handling::EventType; use crate::message_handling::EventType;
use crate::message_handling::handle_recevied_message; use crate::message_handling::handle_recevied_message;
@@ -111,17 +112,11 @@ impl MultipleSenders {
}); });
}*/ }*/
pub fn start_receving_thread( pub fn start_receving_thread(shared_data: &P2PSharedData, socket_addr: SocketAddr) {
socket: &Arc<UdpSocket>, let sock_clone = shared_data.socket();
messages_list: &Arc<Mutex<HashMap<i32, EventType>>>, let cryptopair_clone = shared_data.cryptopair();
crypto_pair: &Arc<CryptographicSignature>, let senders_clone = shared_data.senders();
socket_addr: SocketAddr, let messages_clone = shared_data.messages_list();
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);
thread::spawn(move || { thread::spawn(move || {
let mut buf = [0u8; 1024]; let mut buf = [0u8; 1024];
loop { 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 /// 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 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?; let res = client.get(uri).send().await?;
if res.status().is_success() { if res.status().is_success() {
println!("Successfully retreived the addresses."); println!("Successfully retreived the addresses.");
@@ -70,7 +70,7 @@ pub fn register_ip_addresses(
crypto_pair: &CryptographicSignature, crypto_pair: &CryptographicSignature,
server_uri: String, server_uri: String,
senders: &MultipleSenders, senders: &MultipleSenders,
messages_list: &Arc<Mutex<HashMap<i32, EventType>>>, messages_list: &Mutex<HashMap<i32, EventType>>,
id: i32, id: i32,
) { ) {
let username_size = crypto_pair.username.len(); let username_size = crypto_pair.username.len();
@@ -92,6 +92,7 @@ pub fn register_ip_addresses(
list.insert(id, EventType::ServerHelloReply); list.insert(id, EventType::ServerHelloReply);
} }
} }
println!("message sent: {}", &id);
// 3. Perform the insertion // 3. Perform the insertion
/*let mut buf = [0u8; 1024]; /*let mut buf = [0u8; 1024];
socket.recv_from(&mut buf).expect("receive failed"); 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 bytes::Bytes;
use rand::Rng;
pub async fn get_peer_list(server_address: String) -> Result<Bytes, reqwest::Error> { pub async fn get_peer_list(server_address: String) -> Result<Bytes, reqwest::Error> {
let client = reqwest::Client::new(); 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?; let body: Bytes = res.bytes().await?;
Ok(body) Ok(body)
} }
pub fn generate_id() -> i32 {
rand::rng().random_range(0..i32::MAX)
}