wip handling root request

client-network/src/registration.rs

@@ -1,10 +1,14 @@
 use bytes::Bytes;
 use getrandom::Error;
 
+use crate::NetworkEvent;
+use crate::P2PSharedData;
 use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message};
 use crate::message_handling::EventType;
 use crate::messages_channels::{Message, MultipleSenders};
 use crate::messages_structure::construct_message;
+use crate::server_communication::generate_id;
+use crossbeam_channel::{Receiver, Sender};
 use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::net::UdpSocket;
@@ -66,23 +70,66 @@ pub fn parse_addresses(input: &String) -> Vec<SocketAddr> {
 ///
 /// registers the IP addresses by sending a Hello request to the server.
 ///
-pub fn register_ip_addresses(
-    crypto_pair: &CryptographicSignature,
-    server_uri: String,
-    senders: &MultipleSenders,
-    messages_list: &Mutex<HashMap<i32, EventType>>,
-    id: i32,
+pub async fn perform_handshake(
+    sd: &P2PSharedData,
+    username: String,
+    ip: String,
+    event_tx: Sender<NetworkEvent>,
 ) {
-    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, server_uri, false);
+    let crypto_pair = sd.cryptopair_ref();
+    let senders = sd.senders_ref();
+    let messages_list = sd.messages_list_ref();
+    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(),
+                                    false,
+                                    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));
+                }
+            }
+        }
+        Err(e) => {
+            let err_msg = format!("failed to retreive socket address: {}", e).to_string();
+            let res = event_tx.send(NetworkEvent::Error(err_msg));
         }
-        None => {}
     }
+
     /*let mut list = messages_list.lock().expect("Failed to lock messages_list");
     match list.get(&id) {
         Some(_) => {