server handshake handling

client-network/src/lib.rs

@@ -30,10 +30,14 @@ pub struct P2PSharedData {
     shared_cryptopair: Arc<CryptographicSignature>,
     shared_messageslist: Arc<Mutex<HashMap<i32, EventType>>>,
     shared_senders: Arc<MultipleSenders>,
+    server_name: Arc<Mutex<String>>,
 }
 
 impl P2PSharedData {
-    pub fn new(username: String) -> Result<P2PSharedData, Error> {
+    pub fn new(
+        username: String,
+        cmd_tx: crossbeam_channel::Sender<NetworkEvent>,
+    ) -> Result<P2PSharedData, Error> {
         let messages_list = HashMap::<i32, EventType>::new();
         let username = String::from(username);
         let crypto_pair = CryptographicSignature::new(username);
@@ -42,13 +46,15 @@ impl P2PSharedData {
         let shared_cryptopair = Arc::new(crypto_pair);
         let shared_messageslist = Arc::new(Mutex::new(messages_list));
 
-        let senders = MultipleSenders::new(1, &shared_socket);
+        let senders = MultipleSenders::new(1, &shared_socket, cmd_tx);
         let shared_senders = Arc::new(senders);
+        let server_name = Arc::new(Mutex::new("".to_string()));
         Ok(P2PSharedData {
             shared_socket: shared_socket,
             shared_cryptopair: shared_cryptopair,
             shared_messageslist: shared_messageslist,
             shared_senders: shared_senders,
+            server_name: server_name,
         })
     }
     pub fn socket(&self) -> Arc<UdpSocket> {
@@ -61,6 +67,14 @@ impl P2PSharedData {
     pub fn messages_list(&self) -> Arc<Mutex<HashMap<i32, EventType>>> {
         self.shared_messageslist.clone()
     }
+    pub fn servername(&self) -> String {
+        let guard = self.server_name.lock().unwrap();
+        guard.to_string()
+    }
+    pub fn set_servername(&self, new: String) {
+        let mut guard = self.server_name.lock().unwrap();
+        *guard = new
+    }
     pub fn senders(&self) -> Arc<MultipleSenders> {
         self.shared_senders.clone()
     }
@@ -98,6 +112,7 @@ pub enum NetworkCommand {
     RequestDirectoryContent(String, String),
     RequestChunk(String, String),
     Disconnect(),
+    ResetServerPeer(),
     // ...
 }
 
@@ -112,6 +127,8 @@ pub enum NetworkEvent {
     FileTreeReceived(String, Vec<MerkleNode>), // peer_id, content
     DataReceived(String, MerkleNode),
     FileTreeRootReceived(String, String),
+    HandshakeFailed(),
+    ServerHandshakeFailed(String),
     // ...
 }
 
@@ -155,7 +172,7 @@ pub fn start_p2p_executor(
                     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);
+                            let server_addr_query = get_socket_address(username.clone(), ip);
 
                             match server_addr_query.await {
                                 Ok(sockaddr_bytes) => {
@@ -163,6 +180,7 @@ pub fn start_p2p_executor(
                                         Ok(s) => {
                                             let addresses = parse_addresses(&s);
                                             if let Some(first) = addresses.first() {
+                                                sd.set_servername(username);
                                                 // first: &SocketAddr
                                                 start_receving_thread(
                                                     sd,
@@ -230,7 +248,7 @@ pub fn start_p2p_executor(
 
                         // Actual server connection
 
-                        shared_data = match P2PSharedData::new(name.clone()) {
+                        shared_data = match P2PSharedData::new(name.clone(), event_tx.clone()) {
                             Ok(sd) => Some(sd),
                             Err(e) => {
                                 let mut err_msg = String::from("failed to initialize socket: ");
@@ -311,6 +329,13 @@ pub fn start_p2p_executor(
                             println!("no p2p data");
                         }
                     }
+                    NetworkCommand::ResetServerPeer() => {
+                        if let Some(sd) = shared_data.as_ref() {
+                            sd.set_servername("".to_string());
+                        } else {
+                            println!("no p2p data");
+                        }
+                    }
                 }
             }