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

62
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,8 +149,10 @@ 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) => {
@@ -138,30 +161,34 @@ pub fn start_p2p_executor(
let addresses = parse_addresses(&s);
if let Some(first) = addresses.first() {
// first: &SocketAddr
/*start_receving_thread(
&shared_socket,
&shared_messageslist,
&shared_cryptopair,
start_receving_thread(
sd,
*first, // copie le SocketAddr (implémente Copy pour SocketAddr)
&shared_senders,
);
register_ip_addresses(
&shared_cryptopair,
sd.cryptopair_ref(),
first.to_string(),
&shared_senders,
&shared_messageslist,
545,
);*/
sd.senders_ref(),
sd.messages_list_ref(),
generate_id(),
);
//let res = event_tx.send(NetworkEvent::Connected());
let res = event_tx
.send(NetworkEvent::ConnectedHandshake());
} else {
//let res = event_tx.send(NetworkEvent::Error());
eprintln!("no valid socket addresses found in: {}", s);
eprintln!(
"no valid socket addresses found in: {}",
s
);
}
}
Err(e) => {
//let res = event_tx.send(NetworkEvent::Error());
eprintln!("invalid UTF-8 in socket address bytes: {}", e);
eprintln!(
"invalid UTF-8 in socket address bytes: {}",
e
);
}
}
}
@@ -173,6 +200,7 @@ pub fn start_p2p_executor(
}
}
}
}
NetworkCommand::ConnectPeer(addr) => {
println!("[Network] ConnectPeer() called");
println!("[Network] Attempting to connect to: {}", addr);

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