implementation

client-network/src/registration.rs

@@ -1,11 +1,11 @@
 use bytes::Bytes;
-use getrandom::Error;
 
 use crate::NetworkEvent;
 use crate::P2PSharedData;
 use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message};
+use crate::get_socket_address;
 use crate::message_handling::EventType;
-use crate::messages_channels::{Message, MultipleSenders};
+use crate::messages_channels::MultipleSenders;
 use crate::messages_structure::construct_message;
 use crate::server_communication::generate_id;
 use crossbeam_channel::{Receiver, Sender};
@@ -33,26 +33,6 @@ pub async fn register_with_the_server(
     Ok(())
 }
 
-///
-/// sends a get request to the server to get the socket address of the given peer
-///
-
-pub async fn get_socket_address(username: String, ip: String) -> Result<Bytes, reqwest::Error> {
-    let client = reqwest::Client::new();
-    let uri = format!("{}/peers/{}/addresses", ip, username);
-    let res = client.get(uri).send().await?;
-    if res.status().is_success() {
-        println!("Successfully retreived the addresses.");
-    } else {
-        eprintln!(
-            "Failed to get the peers addresses from the server. Status: {}",
-            res.status()
-        );
-    }
-    let body: Bytes = res.bytes().await?;
-    Ok(body)
-}
-
 pub fn parse_addresses(input: &String) -> Vec<SocketAddr> {
     let mut addrs = Vec::new();
     for line in input.lines() {
@@ -84,49 +64,28 @@ pub async fn perform_handshake(
     let id = generate_id();
     let server_addr_query = get_socket_address(username.clone(), ip.clone());
     match server_addr_query.await {
-        Ok(sockaddr_bytes) => {
-            match String::from_utf8(sockaddr_bytes.to_vec()) {
-                Ok(s) => {
-                    let addresses = parse_addresses(&s);
-                    if let Some(first) = addresses.first() {
-                        sd.set_servername(username);
-                        // first: &SocketAddr
-                        let mut payload = Vec::new();
-                        payload.extend_from_slice(&0u32.to_be_bytes());
-                        payload.extend_from_slice(&crypto_pair.username.clone().as_bytes());
-                        let hello_handshake = construct_message(1, payload, id, crypto_pair);
-                        match hello_handshake {
-                            Some(handshake_message) => {
-                                senders.send_via(
-                                    0,
-                                    handshake_message,
-                                    first.to_string(),
-                                    is_server_handshake,
-                                    messages_list,
-                                );
-                            }
-                            None => {}
-                        }
-
-                        //let res = event_tx
-                        //    .send(NetworkEvent::());
-                    } else {
-                        //let res = event_tx.send(NetworkEvent::Error());
-                        let err_msg =
-                            format!("no valid socket addresses found in: {}", s).to_string();
-                        let res = event_tx.send(NetworkEvent::Error(err_msg));
-                    }
-                }
-                Err(e) => {
-                    //let res = event_tx.send(NetworkEvent::Error());
-                    let err_msg =
-                        format!("invalid UTF-8 in socket address bytes: {}", e).to_string();
-                    let res = event_tx.send(NetworkEvent::Error(err_msg));
+        Some(sockaddr_bytes) => {
+            sd.set_servername(username);
+            // first: &SocketAddr
+            let mut payload = Vec::new();
+            payload.extend_from_slice(&0u32.to_be_bytes());
+            payload.extend_from_slice(&crypto_pair.username.clone().as_bytes());
+            let hello_handshake = construct_message(1, payload, id, crypto_pair);
+            match hello_handshake {
+                Some(handshake_message) => {
+                    senders.send_via(
+                        0,
+                        handshake_message,
+                        sockaddr_bytes.to_string(),
+                        is_server_handshake,
+                        messages_list,
+                    );
                 }
+                None => {}
             }
         }
-        Err(e) => {
-            let err_msg = format!("failed to retreive socket address: {}", e).to_string();
+        None => {
+            let err_msg = format!("failed to retreive socket address:").to_string();
             let res = event_tx.send(NetworkEvent::Error(err_msg));
         }
     }