some modifications

client-network/src/cryptographic_signature.rs

@@ -7,6 +7,7 @@ use p256::ecdsa::{
     signature::{Signer, Verifier},
 };
 use rand_core::OsRng;
+use reqwest::Error;
 use sha2::{Digest, Sha256};
 
 ///
@@ -50,19 +51,24 @@ pub async fn get_peer_key(username: &String) -> Result<VerifyingKey, reqwest::Er
     let client = reqwest::Client::new();
     let uri = format!("https://jch.irif.fr:8443/peers/{}/key", username);
     let res = client.get(uri).send().await?;
-    if res.status().is_success() {
+
-        println!("Successfully retreived the peers key.");
+    match res.error_for_status_ref() {
-    } else {
+        Ok(_) => {
-        eprintln!(
+            println!("Successfully retreived the peers key.");
-            "Failed to get the peers key from the server. Status: {}",
+            let body: Bytes = res.bytes().await?;
-            res.status()
+            let slice: &[u8] = body.as_ref();
-        );
+            let body_bytes: &[u8; 64] = slice.try_into().expect("size error");
+            let received_key = convert_verifyingkey(body_bytes);
+            Ok(received_key)
+        }
+        Err(e) => {
+            eprintln!(
+                "Failed to get the peers key from the server. Status: {}",
+                res.status()
+            );
+            Err(e)
+        }
     }
-    let body: Bytes = res.bytes().await?;
-    let slice: &[u8] = body.as_ref();
-    let body_bytes: &[u8; 64] = slice.try_into().expect("size error");
-    let received_key = convert_verifyingkey(body_bytes);
-    Ok(received_key)
 }
 
 fn convert_verifyingkey(raw_xy: &[u8; 64]) -> VerifyingKey {

client-network/src/lib.rs

@@ -461,12 +461,31 @@ pub async fn get_socket_address(username: String, ip: String) -> Option<SocketAd
     match String::from_utf8(body.to_vec()) {
         Ok(s) => {
             let addresses = parse_addresses(&s);
-            if let Some(first) = addresses.first() {
+            addresses.iter().copied().find(|a| a.is_ipv4())
-                Some(first.clone())
-            } else {
-                None
-            }
         }
         Err(_) => None,
     }
 }
+
+pub async fn get_possible_socket_address(username: String, ip: String) -> Vec<SocketAddr> {
+    let client = reqwest::Client::new();
+    let uri = format!("{}/peers/{}/addresses", ip, username);
+    let res = client.get(uri).send().await.expect("couldnt get response");
+    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.expect("couldnt get bytes");
+
+    match String::from_utf8(body.to_vec()) {
+        Ok(s) => {
+            let addresses = parse_addresses(&s);
+            addresses.iter().copied().filter(|a| a.is_ipv4()).collect()
+        }
+        Err(_) => Vec::new(),
+    }
+}