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

registration put

Browse Source
This commit is contained in:
wikano
2026-01-02 22:27:26 +01:00
parent 1d72d7500a
commit 1914c68c9f
3 changed files with 181 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -5,7 +5,7 @@ use client_network::{
use crossbeam_channel::{Receiver, Sender}; use crossbeam_channel::{Receiver, Sender};
use egui::{ use egui::{
Align, Align2, Button, CentralPanel, CollapsingHeader, Context, Id, LayerId, Layout, Order, Align, Align2, Button, CentralPanel, CollapsingHeader, Context, Id, LayerId, Layout, Order,
Popup, ScrollArea, SidePanel, TopBottomPanel, Ui, ViewportCommand, Popup, ScrollArea, SidePanel, TextStyle, TopBottomPanel, Ui, ViewportCommand,
}; };
use std::collections::HashMap; use std::collections::HashMap;
@@ -29,7 +29,8 @@ pub struct P2PClientApp {
status_message: String, status_message: String,
known_peers: Vec<String>, known_peers: Vec<String>,
connect_address_input: String, connect_address_input: String,
connect_server_name_input: String, connected_address: String,
connect_name_input: String,
// Key: Parent Directory Hash (String), Value: List of children FileNode // Key: Parent Directory Hash (String), Value: List of children FileNode
loaded_fs: HashMap<String, MerkleTree>, loaded_fs: HashMap<String, MerkleTree>,
@@ -40,6 +41,8 @@ pub struct P2PClientApp {
server_status: ServerStatus, server_status: ServerStatus,
show_network_popup: bool, // gérer selon besoin show_network_popup: bool, // gérer selon besoin
error_message: Option<String>, // Some(message) -> afficher, None -> rien
} }
impl P2PClientApp { impl P2PClientApp {
@@ -59,13 +62,21 @@ impl P2PClientApp {
status_message: "Client Initialized. Awaiting network status...".to_string(), status_message: "Client Initialized. Awaiting network status...".to_string(),
known_peers: vec!["bob".to_string()], known_peers: vec!["bob".to_string()],
connect_address_input: "https://jch.irif.fr:8443".to_string(), connect_address_input: "https://jch.irif.fr:8443".to_string(),
connect_server_name_input: "jch.irif.fr".to_string(), connected_address: "".to_string(),
loaded_fs, loaded_fs,
active_peer: None, active_peer: None,
server_status: ServerStatus::NotConnected, server_status: ServerStatus::NotConnected,
show_network_popup: false, show_network_popup: false,
error_message: None,
connect_name_input: "bob".to_string(),
} }
} }
pub fn show_error(&mut self, msg: impl Into<String>) {
self.error_message = Some(msg.into());
}
pub fn clear_error(&mut self) {
self.error_message = None;
}
} }
// --- eframe::App Trait Implementation --- // --- eframe::App Trait Implementation ---
@@ -127,14 +138,24 @@ impl eframe::App for P2PClientApp {
// root_hash, // root_hash,
// )); // ));
} }
NetworkEvent::Connected() => { NetworkEvent::Connected(ip) => {
self.server_status = ServerStatus::Connected; self.server_status = ServerStatus::Connected;
self.connected_address = ip.clone();
let _ = self.network_cmd_tx.send(NetworkCommand::FetchPeerList(
self.connected_address.clone(),
));
} }
NetworkEvent::ConnectedHandshake() => { NetworkEvent::ConnectedHandshake() => {
self.server_status = ServerStatus::ConnectedHandshake; self.server_status = ServerStatus::ConnectedHandshake;
} }
NetworkEvent::Disconnected() => todo!(), NetworkEvent::Disconnected() => {
NetworkEvent::Error() => todo!(), self.connected_address = "".to_string();
self.known_peers.clear();
self.server_status = ServerStatus::NotConnected;
}
NetworkEvent::Error(err) => {
self.show_error(err);
}
NetworkEvent::DataReceived(_, merkle_node) => todo!(), NetworkEvent::DataReceived(_, merkle_node) => todo!(),
} }
} }
@@ -154,34 +175,60 @@ impl eframe::App for P2PClientApp {
}); });
ui.menu_button("Network", |ui| { ui.menu_button("Network", |ui| {
ui.vertical(|ui| { match self.server_status {
ui.horizontal(|ui| { ServerStatus::Connected | ServerStatus::ConnectedHandshake => {
ui.label("Server IP:"); let desired = egui::vec2(300.0, 0.0); // width 300, auto-height if 0
ui.text_edit_singleline(&mut self.connect_address_input); ui.set_min_size(desired);
}); ui.vertical(|ui| {
if ui.button("Disconnect").clicked() {
println!("Disconnecting...");
let _ = self.network_cmd_tx.send(NetworkCommand::Disconnect());
self.server_status = ServerStatus::NotConnected;
self.remaining = std::time::Duration::from_secs(0);
self.timer_started = false;
ui.close();
}
});
}
ServerStatus::NotConnected => {
let desired = egui::vec2(0.0, 0.0); // width 300, auto-height if 0
ui.set_min_size(desired);
ui.vertical(|ui| {
ui.horizontal(|ui| {
ui.label("Server IP:");
ui.text_edit_singleline(&mut self.connect_address_input);
});
ui.horizontal(|ui| {
ui.label("Name:");
ui.text_edit_singleline(&mut self.connect_name_input);
});
if ui.button("Connect").clicked() {
let addr = self.connect_address_input.clone();
let name = self.connect_name_input.clone();
let _ = self
.network_cmd_tx
.send(NetworkCommand::ConnectToServerPut(addr, name));
self.server_status = ServerStatus::Loading;
ui.close();
}
});
}
_ => {}
}
/* ui.horizontal(|ui| {
ui.label("Server peer name:");
ui.text_edit_singleline(&mut self.connect_server_name_input);
if ui.button("Connect").clicked() { if ui.button("Connect").clicked() {
let addr = self.connect_address_input.clone(); let addr = self.connect_address_input.clone();
let serv_name = self.connect_server_name_input.clone();
let _ = self let _ = self
.network_cmd_tx .network_cmd_tx
.send(NetworkCommand::ConnectToServerPut(addr)); .send(NetworkCommand::ConnectToServer(addr, serv_name));
self.server_status = ServerStatus::Loading; self.server_status = ServerStatus::Loading;
ui.close(); ui.close();
} }
});*/
/* ui.horizontal(|ui| {
ui.label("Server peer name:");
ui.text_edit_singleline(&mut self.connect_server_name_input);
if ui.button("Connect").clicked() {
let addr = self.connect_address_input.clone();
let serv_name = self.connect_server_name_input.clone();
let _ = self
.network_cmd_tx
.send(NetworkCommand::ConnectToServer(addr, serv_name));
self.server_status = ServerStatus::Loading;
ui.close();
}
});*/
});
}); });
// état // état
@@ -262,8 +309,9 @@ impl eframe::App for P2PClientApp {
ui.heading("🌐 Known Peers"); ui.heading("🌐 Known Peers");
ui.add_space(20.0); ui.add_space(20.0);
if ui.button("🔄").clicked() { if ui.button("🔄").clicked() {
println!("addr:{}", self.connected_address.clone());
let res = self.network_cmd_tx.send(NetworkCommand::FetchPeerList( let res = self.network_cmd_tx.send(NetworkCommand::FetchPeerList(
self.connect_address_input.clone(), self.connected_address.clone(),
)); ));
if let Some(error) = res.err() { if let Some(error) = res.err() {
println!( println!(
@@ -350,6 +398,21 @@ impl eframe::App for P2PClientApp {
// ui.label(format!("Status: {}", self.status_message)); // ui.label(format!("Status: {}", self.status_message));
}); });
if let Some(msg) = &self.error_message {
let msg = msg.clone();
egui::Window::new("Error")
.collapsible(false)
.resizable(false)
.anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
.show(ctx, |ui| {
ui.label(&msg);
if ui.button("OK").clicked() {
self.clear_error();
}
});
ctx.request_repaint();
}
ctx.request_repaint_after(std::time::Duration::from_millis(10)); ctx.request_repaint_after(std::time::Duration::from_millis(10));
} }
} }

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

@@ -17,6 +17,7 @@ use crate::{
}; };
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use std::{ use std::{
io::Error,
net::{SocketAddr, UdpSocket}, net::{SocketAddr, UdpSocket},
str::FromStr, str::FromStr,
}; };
@@ -29,47 +30,59 @@ pub struct P2PSharedData {
} }
impl P2PSharedData { impl P2PSharedData {
pub fn new(username: String) -> P2PSharedData { pub fn new(username: String) -> Result<P2PSharedData, Error> {
let messages_list = HashMap::<i32, EventType>::new(); let messages_list = HashMap::<i32, EventType>::new();
let username = String::from(username); let username = String::from(username);
let crypto_pair = CryptographicSignature::new(username); let crypto_pair = CryptographicSignature::new(username);
let socket = UdpSocket::bind("0.0.0.0:0").expect("bind failed"); let socket = UdpSocket::bind("0.0.0.0:0")?;
let shared_socket = Arc::new(socket); let shared_socket = Arc::new(socket);
let shared_cryptopair = Arc::new(crypto_pair); let shared_cryptopair = Arc::new(crypto_pair);
let shared_messageslist = Arc::new(Mutex::new(messages_list)); let shared_messageslist = Arc::new(Mutex::new(messages_list));
let senders = MultipleSenders::new(1, &shared_socket); let senders = MultipleSenders::new(1, &shared_socket);
let shared_senders = Arc::new(senders); let shared_senders = Arc::new(senders);
P2PSharedData { Ok(P2PSharedData {
shared_socket: shared_socket, shared_socket: shared_socket,
shared_cryptopair: shared_cryptopair, shared_cryptopair: shared_cryptopair,
shared_messageslist: shared_messageslist, shared_messageslist: shared_messageslist,
shared_senders: shared_senders, shared_senders: shared_senders,
} })
}
pub fn socket(&self) -> Arc<UdpSocket> {
self.shared_socket.clone()
}
pub fn cryptopair(&self) -> Arc<CryptographicSignature> {
self.shared_cryptopair.clone()
}
pub fn add_message(&self, id: i32, evt: EventType) {
let mut map = self.shared_messageslist.lock().unwrap();
map.insert(id, evt);
} }
} }
/// 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), // ServerIP ConnectToServerPut(String, String), // ServerIP
ServerHandshake(String), // ServerName ServerHandshake(String), // ServerName
FetchPeerList(String), // ServerIP FetchPeerList(String), // ServerIP
RegisterAsPeer(String), RegisterAsPeer(String),
Ping(), Ping(),
ConnectPeer(String), // IP:PORT ConnectPeer(String), // IP:PORT
RequestFileTree(String), // peer_id RequestFileTree(String), // peer_id
RequestDirectoryContent(String, String), RequestDirectoryContent(String, String),
RequestChunk(String, String), RequestChunk(String, String),
Disconnect(),
// ... // ...
} }
/// Messages sent to the GUI by the Network thread. /// Messages sent to the GUI by the Network thread.
pub enum NetworkEvent { pub enum NetworkEvent {
Connected(), Connected(String),
ConnectedHandshake(), ConnectedHandshake(),
Disconnected(), Disconnected(),
Error(), Error(String),
PeerConnected(String), PeerConnected(String),
PeerListUpdated(Vec<String>), PeerListUpdated(Vec<String>),
FileTreeReceived(String, Vec<MerkleNode>), // peer_id, content FileTreeReceived(String, Vec<MerkleNode>), // peer_id, content
@@ -102,7 +115,7 @@ pub fn calculate_chunk_id(data: &[u8]) -> String {
pub fn start_p2p_executor( pub fn start_p2p_executor(
cmd_rx: Receiver<NetworkCommand>, cmd_rx: Receiver<NetworkCommand>,
event_tx: Sender<NetworkEvent>, event_tx: Sender<NetworkEvent>,
shared_data: Option<P2PSharedData>, mut shared_data: Option<P2PSharedData>,
) -> tokio::task::JoinHandle<()> { ) -> tokio::task::JoinHandle<()> {
// Use tokio to spawn the asynchronous networking logic // Use tokio to spawn the asynchronous networking logic
tokio::task::spawn(async move { tokio::task::spawn(async move {
@@ -140,21 +153,23 @@ pub fn start_p2p_executor(
545, 545,
);*/ );*/
let res = event_tx.send(NetworkEvent::Connected()); //let res = event_tx.send(NetworkEvent::Connected());
} else { } else {
let res = event_tx.send(NetworkEvent::Error()); //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) => { Err(e) => {
let res = event_tx.send(NetworkEvent::Error()); //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);
} }
} }
} }
Err(e) => { Err(e) => {
eprintln!("failed to retrieve socket address: {}", e); let mut err_msg =
let res = event_tx.send(NetworkEvent::Error()); String::from("failed to retrieve socket address:");
err_msg += &e.to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg));
} }
} }
} }
@@ -174,35 +189,35 @@ pub fn start_p2p_executor(
NetworkCommand::RequestChunk(_, _) => { NetworkCommand::RequestChunk(_, _) => {
println!("[Network] RequestChunk() called"); println!("[Network] RequestChunk() called");
} }
NetworkCommand::ConnectToServerPut(ip) => { NetworkCommand::ConnectToServerPut(ip, name) => {
println!("[Network] ConnectToServer() called"); println!("[Network] ConnectToServer() called");
// Actual server connection // Actual server connection
let messages_list = HashMap::<i32, EventType>::new(); shared_data = match P2PSharedData::new(name.clone()) {
Ok(sd) => Some(sd),
Err(e) => {
let mut err_msg = String::from("failed to initialize socket: ");
err_msg += &e.to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg));
let res = event_tx.send(NetworkEvent::Disconnected());
None
}
};
let username = String::from("Gamemeixtreize"); if let Some(sd) = shared_data.as_ref() {
if let Err(e) = register_with_the_server(&sd.cryptopair(), &ip).await {
let crypto_pair = CryptographicSignature::new(username); let mut err_msg = String::from("request failed: ");
err_msg += &e.to_string();
let socket = UdpSocket::bind("0.0.0.0:0").expect("bind failed"); let res = event_tx.send(NetworkEvent::Error(err_msg));
let res = event_tx.send(NetworkEvent::Disconnected());
let shared_socket = Arc::new(socket); } else {
let shared_cryptopair = Arc::new(crypto_pair); let res = event_tx.send(NetworkEvent::Connected(ip));
let shared_messageslist = Arc::new(Mutex::new(messages_list)); println!("username created: {}", sd.cryptopair().username);
}
let senders = MultipleSenders::new(1, &shared_socket); //println!("ip: {}", ip);
let shared_senders = Arc::new(senders);
if let Err(e) = register_with_the_server(&shared_cryptopair, &ip).await {
let res = event_tx.send(NetworkEvent::Error());
eprintln!("request failed: {}", e);
} }
let res = event_tx.send(NetworkEvent::Connected());
println!("ip: {}", ip);
//tokio::time::sleep(std::time::Duration::from_millis(5000)).await; //tokio::time::sleep(std::time::Duration::from_millis(5000)).await;
/*let res = event_tx.send(NetworkEvent::Connected()); /*let res = event_tx.send(NetworkEvent::Connected());
@@ -214,27 +229,34 @@ pub fn start_p2p_executor(
}*/ }*/
} }
NetworkCommand::FetchPeerList(ip) => { NetworkCommand::FetchPeerList(ip) => {
println!("cc"); if ip == "" {
match get_peer_list(String::from("https://jch.irif.fr:8443")).await { let res = event_tx.send(NetworkEvent::Error(
Ok(body) => match String::from_utf8(body.to_vec()) { "Not registered to any server".to_string(),
Ok(peers_list) => { ));
let mut peers: Vec<String> = Vec::new(); } else {
let mut current = String::new(); println!("cc");
for i in peers_list.chars() { match get_peer_list(ip).await {
if i == '\n' { Ok(body) => match String::from_utf8(body.to_vec()) {
peers.push(current.clone()); Ok(peers_list) => {
current.clear(); let mut peers: Vec<String> = Vec::new();
} else { let mut current = String::new();
current.push(i); for i in peers_list.chars() {
if i == '\n' {
peers.push(current.clone());
current.clear();
} else {
current.push(i);
}
} }
let res =
event_tx.send(NetworkEvent::PeerListUpdated(peers));
} }
let res = event_tx.send(NetworkEvent::PeerListUpdated(peers)); Err(e) => {
} eprintln!("invalid UTF-8 in socket address bytes: {}", e);
Err(e) => { }
eprintln!("invalid UTF-8 in socket address bytes: {}", e); },
} Err(e) => println!("error"),
}, }
Err(e) => println!("error"),
} }
println!("[Network] FetchPeerList() called"); println!("[Network] FetchPeerList() called");
} }
@@ -244,6 +266,15 @@ pub fn start_p2p_executor(
NetworkCommand::Ping() => { NetworkCommand::Ping() => {
println!("[Network] Ping() called"); println!("[Network] Ping() called");
} }
NetworkCommand::Disconnect() => {
if let Some(sd) = shared_data.as_ref() {
println!("Disconnecting: {}", &sd.cryptopair().username);
shared_data = None;
let res = event_tx.send(NetworkEvent::Disconnected());
} else {
println!("no p2p data");
}
}
} }
} }

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

@@ -1,4 +1,5 @@
use bytes::Bytes; use bytes::Bytes;
use getrandom::Error;
use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message}; use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message};
use crate::message_handling::EventType; use crate::message_handling::EventType;
@@ -23,15 +24,7 @@ pub async fn register_with_the_server(
let pubkey_bytes = encoded_point.as_ref().to_vec(); let pubkey_bytes = encoded_point.as_ref().to_vec();
let pubkey_bytes_minus = pubkey_bytes[1..].to_vec(); let pubkey_bytes_minus = pubkey_bytes[1..].to_vec();
let res = client.put(uri).body(pubkey_bytes_minus).send().await?; let res = client.put(uri).body(pubkey_bytes_minus).send().await?;
if res.status().is_success() { let res = res.error_for_status()?;
let str = hex::encode(res.bytes().await?);
println!("Successfully registered with the server : {}", str);
} else {
eprintln!(
"Failed to register with the server. Status: {}",
res.status()
);
}
println!("register ip adresses"); println!("register ip adresses");
Ok(()) Ok(())
} }