wip handling root request

client-network/src/message_handling.rs

@@ -5,7 +5,9 @@ use crate::{
     },
     messages_channels::MultipleSenders,
     messages_structure::construct_message,
+    peers_refresh::HandshakeHistory,
     registration,
+    server_communication::generate_id,
 };
 use std::{collections::HashMap, net::SocketAddr};
 use std::{
@@ -14,9 +16,7 @@ use std::{
 };
 
 pub enum EventType {
-    ServerHelloReply,
-    PeerHelloReply,
-    PeerHello,
+    SendRootRequest,
 }
 
 const ID: usize = 4;
@@ -42,11 +42,12 @@ pub fn handle_recevied_message(
     messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
     recevied_message: &Vec<u8>,
     crypto_pair: &CryptographicSignature,
-    socket_addr: &SocketAddr,
+    //socket_addr: &SocketAddr,
     senders: &MultipleSenders,
     server_name: &String,
     cmd_tx: crossbeam_channel::Sender<NetworkEvent>,
     ip: SocketAddr,
+    handshake_history: HandshakeHistory,
 ) {
     if recevied_message.len() < 4 {
         return;
@@ -70,13 +71,27 @@ pub fn handle_recevied_message(
         }
     }
 
-    let resp = parse_message(recevied_message.to_vec(), id, crypto_pair, cmd_tx, ip);
+    let resp = parse_message(
+        recevied_message.to_vec(),
+        id,
+        crypto_pair,
+        cmd_tx,
+        ip,
+        messages_list,
+        handshake_history,
+    );
 
     match resp {
         None => {}
         Some(resp_msg) => {
             println!("msg_sent:{:?}", resp_msg);
-            senders.send_via(0, resp_msg, ip.to_string(), is_resp_to_server_handshake);
+            senders.send_via(
+                0,
+                resp_msg,
+                ip.to_string(),
+                is_resp_to_server_handshake,
+                messages_list,
+            );
         }
     }
 
@@ -152,6 +167,8 @@ pub fn parse_message(
     crypto_pair: &CryptographicSignature,
     cmd_tx: crossbeam_channel::Sender<NetworkEvent>,
     ip: SocketAddr,
+    messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
+    handhsake_history: HandshakeHistory,
 ) -> Option<Vec<u8>> {
     let cmd_tx_clone = cmd_tx.clone();
 
@@ -166,7 +183,6 @@ pub fn parse_message(
         .expect("Taille incorrecte");
 
     let msg_length = u16::from_be_bytes(length_bytes) as usize;
-
     // verify signature
     match msgtype {
         HELLO | HELLOREPLY | ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => {
@@ -176,10 +192,13 @@ pub fn parse_message(
             let received_username = String::from_utf8(received_name.to_vec());
             match received_username {
                 Ok(username) => {
-                    let peer_pubkey = tokio::runtime::Runtime::new()
-                        .unwrap()
-                        .block_on(get_peer_key(&username))
-                        .expect("failed to retrieve public key");
+                    let peer_pubkey = match handhsake_history.get_peer_info_username(username) {
+                        Some(peerinfo) => peerinfo.pubkey,
+                        _ => tokio::runtime::Runtime::new()
+                            .unwrap()
+                            .block_on(get_peer_key(&username))
+                            .expect("failed to retrieve public key"),
+                    };
                     let signature: [u8; SIGNATURE] = received_message
                         [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE]
                         .try_into()
@@ -248,7 +267,30 @@ pub fn parse_message(
         //
         //
         // ajoute a la liste des peers handshake
-        HELLOREPLY => {}
+        HELLOREPLY => {
+            // ajoute a la liste des peers handshake
+            handhsake_history.add_new_handshake(hash, username, ip);
+            // verifie s'il faut renvoyer un root request
+            let guard = messages_list.lock().expect("Échec du verrouillage");
+            let res = guard.get(&id);
+            match res {
+                Some(ev) => {
+                    match ev {
+                        EventType::SendRootRequest => {
+                            // envoyer la root request
+                            let rootrequest = construct_message(
+                                ROOTREQUEST,
+                                Vec::new(),
+                                generate_id(),
+                                crypto_pair,
+                            );
+                            return rootrequest;
+                        }
+                    }
+                }
+                None => {}
+            }
+        }
         //
         // ROOTREQUEST
         //
@@ -256,7 +298,20 @@ pub fn parse_message(
         //
         // ROOTREPLY
         //
-        // envoie un datum request
+        ROOTREPLY => {
+            // recuperer le pseudo du peers ayant repondu
+
+            // envoyer le hash a la gui
+            let received_hash = String::from_utf8(received_message[LENGTH..(32 + LENGTH)].to_vec());
+            match received_hash {
+                Ok(hash) => {
+                    cmd_tx_clone.send(NetworkEvent::FileTreeRootReceived());
+                }
+                Err(e) => {
+                    println!("{}", e);
+                }
+            }
+        }
         //
         // DATUMREQUEST
         //
@@ -328,6 +383,6 @@ pub fn parse_message(
         //
         // envoie OK à S puis envoie un ping à S
         _ => return None,
-    }
+    };
     constructed_message
 }