feat: working on spawning commands

sparse-05/sparse-05-server/src/connection.rs

@@ -229,46 +229,59 @@ where
     use packets::*;
 
     let mut commands = HashMap::new();
-    let mut uploaded_files = HashMap::new();
-    let mut downloaded_files = HashMap::new();
+    /*let mut uploaded_files = HashMap::new();
+    let mut downloaded_files = HashMap::new();*/
 
-    loop {
-        let msg = packet_handler.recv()?;
-        let pkt = msg.pkt();
+    std::thread::scope(|s| -> anyhow::Result<()> {
+        loop {
+            let msg = packet_handler.recv()?;
+            let pkt = msg.pkt();
 
-        let Layer3Pkt::IPv4Pkt(ip_pkt) = pkt.get_layer3_pkt()?;
-        let Layer4Pkt::UDP(udp_pkt) = ip_pkt.get_layer4_packet()?;
+            let Layer3Pkt::IPv4Pkt(ip_pkt) = pkt.get_layer3_pkt()?;
+            let Layer4Pkt::UDP(udp_pkt) = ip_pkt.get_layer4_packet()?;
 
-        if ip_pkt.source_ip() != conninfo.srcip || udp_pkt.srcport() != conninfo.srcport {
-            continue;
-        }
+            if ip_pkt.source_ip() != conninfo.srcip || udp_pkt.srcport() != conninfo.srcport {
+                continue;
+            }
 
-        let Ok(data) = conninfo.try_decrypt_and_verify_comm(udp_pkt.get_data()) else {
-            continue;
-        };
+            let Ok(data) = conninfo.try_decrypt_and_verify_comm(udp_pkt.get_data()) else {
+                continue;
+            };
 
-        match data {
-            Command::RunCommand(_) => {}
-            Command::SendStdin(_, _) => {}
+            match data {
+                Command::RunCommand(comm) => {
+                    let handler = match command::spawn_command(&s, comm, &conninfo) {
+                        Ok(handler) => handler,
+                        Err(e) => {
+                            eprintln!("error spawning command: {e:?}");
+                            continue;
+                        }
+                    };
 
-            Command::Cd(_) => {}
-            Command::Ls(_) => {}
+                    commands.insert(handler.id, handler);
+                }
+                Command::SendStdin(_, _) => {}
 
-            Command::OpenTTY => {}
-            Command::CloseTTY(_) => {}
-            Command::SendTTYData(_, _) => {}
-            Command::SendTTYSignal(_, _) => {}
+                Command::Cd(_) => {}
+                Command::Ls(_) => {}
 
-            Command::StartUploadFile(_, _) => {}
-            Command::SendFileSegment(_, _, _) => {}
-            Command::StartDownloadFile(_) => {}
-            Command::DownloadFileStatus(_) => {}
+                Command::OpenTTY => {}
+                Command::CloseTTY(_) => {}
+                Command::SendTTYData(_, _) => {}
+                Command::SendTTYSignal(_, _) => {}
 
-            Command::Disconnect => {
-                break;
+                Command::StartUploadFile(_, _) => {}
+                Command::SendFileSegment(_, _, _) => {}
+                Command::StartDownloadFile(_) => {}
+                Command::DownloadFileStatus(_) => {}
+
+                Command::Disconnect => {
+                    break;
+                }
             }
         }
-    }
+        Ok(())
+    })?;
 
     close();
 

sparse-05/sparse-05-server/src/connection/command.rs

@@ -0,0 +1,29 @@
+use std::{
+    sync::{
+        atomic::AtomicU64,
+        mpsc::{channel, Sender},
+    },
+    thread::Scope,
+};
+
+use super::ConnectionInformation;
+
+const CURRENT_COMMAND_ID: AtomicU64 = AtomicU64::new(0);
+
+pub(super) struct CommandHandler {
+    pub id: u64,
+    data_sender: Sender<Vec<u8>>,
+}
+
+pub(super) fn spawn_command<'a, 'b: 'a>(
+    s: &'a Scope<'a, 'b>,
+    command: String,
+    conninfo: &'a ConnectionInformation,
+) -> anyhow::Result<CommandHandler> {
+    let (data_sender, data_receiver) = channel();
+
+    Ok(CommandHandler {
+        id: CURRENT_COMMAND_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
+        data_sender,
+    })
+}