Implement the socket loop

Doesn't work though. Debugging time!

apps/app-playground/src/main.rs

@@ -82,7 +82,7 @@ async fn main_client() -> theseus::Result<()> {
         .expect("Expected second CLI arg to be socket ID")
         .parse::<Uuid>()?;
 
-    tracing::info!("Listening on port 25565 to connect to {socket_id}");
+    tracing::info!("Listening on port 25585 to connect to {socket_id}");
     let tcp_stream =
         TcpListener::bind(SocketAddr::new("127.0.0.1".parse().unwrap(), 25585))
             .await?

packages/app-lib/src/state/friends.rs

@@ -24,7 +24,8 @@ use serde::{Deserialize, Serialize};
 use std::net::SocketAddr;
 use std::ops::Deref;
 use std::sync::Arc;
-use tokio::io::AsyncWriteExt;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::tcp::OwnedReadHalf;
 use tokio::net::TcpStream;
 use tokio::sync::{Mutex, RwLock};
 use uuid::Uuid;
@@ -180,7 +181,9 @@ impl FriendsSocket {
                                                 if let Some(connected_to) = sockets.get(&to_socket) {
                                                     if let InternalTunnelSocket::Listening(local_addr) = *connected_to.value().clone() {
                                                         if let Ok(new_stream) = TcpStream::connect(local_addr).await {
-                                                            sockets.insert(new_socket, Arc::new(InternalTunnelSocket::Connected(Mutex::new(new_stream))));
+                                                            let (read, write) = new_stream.into_split();
+                                                            sockets.insert(new_socket, Arc::new(InternalTunnelSocket::Connected(Mutex::new(write))));
+                                                            Self::socket_read_loop(write_handle.clone(), read, new_socket);
                                                             continue;
                                                         }
                                                     }
@@ -380,8 +383,9 @@ impl FriendsSocket {
         stream: TcpStream,
     ) -> crate::Result<TunnelSocket> {
         let socket_id = Uuid::new_v4();
+        let (read, write) = stream.into_split();
         let socket = self.tunnel_sockets.entry(socket_id).insert(Arc::new(
-            InternalTunnelSocket::Connected(Mutex::new(stream)),
+            InternalTunnelSocket::Connected(Mutex::new(write)),
         ));
         Self::send_message(
             &self.write,
@@ -391,6 +395,7 @@ impl FriendsSocket {
             },
         )
         .await?;
+        Self::socket_read_loop(self.write.clone(), read, socket_id);
         self.create_tunnel_socket(socket_id, socket)
     }
 
@@ -407,6 +412,31 @@ impl FriendsSocket {
         })
     }
 
+    fn socket_read_loop(
+        write: WriteSocket,
+        mut read_half: OwnedReadHalf,
+        socket_id: Uuid,
+    ) {
+        tokio::spawn(async move {
+            let mut read_buffer = [0u8; 8192];
+            loop {
+                match read_half.read(&mut read_buffer).await {
+                    Ok(0) | Err(_) => break,
+                    Ok(n) => {
+                        let _ = Self::send_message(
+                            &write,
+                            ClientToServerMessage::SocketSend {
+                                socket: socket_id,
+                                data: read_buffer[..n].to_vec(),
+                            },
+                        )
+                        .await;
+                    }
+                };
+            }
+        });
+    }
+
     #[tracing::instrument(skip(write))]
     pub(super) async fn send_message(
         write: &WriteSocket,

packages/app-lib/src/state/tunnel.rs

@@ -4,13 +4,13 @@ use rust_common::networking::message::ClientToServerMessage;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::io::AsyncWriteExt;
-use tokio::net::TcpStream;
+use tokio::net::tcp::OwnedWriteHalf;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 
 pub(super) enum InternalTunnelSocket {
     Listening(SocketAddr),
-    Connected(Mutex<TcpStream>),
+    Connected(Mutex<OwnedWriteHalf>),
 }
 
 pub struct TunnelSocket {