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

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

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