feat: working on spawning commands

Cargo.lock

@@ -1042,7 +1042,6 @@ dependencies = [
  "rmp-serde",
  "serde",
  "sparse-05-common",
- "sparse-05-server",
  "structopt",
  "tokio",
 ]

sparse-05/sparse-05-client/Cargo.toml

@@ -14,6 +14,5 @@ raw_tty = "0.1.0"
 rmp-serde = "1.1.2"
 serde = { version = "1.0.188", features = ["derive"] }
 sparse-05-common = { version = "0.1.0", path = "../sparse-05-common" }
-sparse-05-server = { version = "0.5.0", path = "../sparse-05-server" }
 structopt = { version = "0.3.26", features = ["paw"] }
 tokio = { version = "1.32.0", features = ["io-std", "net", "fs", "macros", "rt"] }

sparse-05/sparse-05-client/src/commands/connect/commands/help.rs

@@ -11,6 +11,9 @@ pub fn print_help(arg: Option<SparseCommands>) {
         Some(SparseCommands::SysInfo) => println!(
             "Prints system information from the system you are connecting to"
         ),
+        Some(SparseCommands::Cd { .. }) => println!(
+            "Changes the current working directory you are in"
+        ),
         None => println!(
             "\n{}{}\n\
             \n\

sparse-05/sparse-05-client/src/commands/connect/shell.rs

@@ -1,6 +1,7 @@
 use std::{
     io::{self, Read, Write},
     os::fd::AsRawFd,
+    path::PathBuf,
     sync::Arc,
 };
 
@@ -16,6 +17,9 @@ pub enum SparseCommands {
     SysInfo,
     #[structopt(name = "#exit")]
     Exit,
+    Cd {
+        folder: PathBuf,
+    },
 }
 
 macro_rules! libc_try {
@@ -45,6 +49,10 @@ fn convert_termios_raw(attrs: &mut libc::termios) -> anyhow::Result<()> {
     Ok(())
 }
 
+async fn run_command(connection: Arc<Connection>) -> anyhow::Result<()> {
+    Ok(())
+}
+
 pub(super) async fn shell(
     connection: Arc<Connection>,
     mut capabilities: Capabilities,

sparse-05/sparse-05-common/src/lib.rs

@@ -12,7 +12,7 @@ pub mod messages {
 
     #[derive(Serialize, Deserialize)]
     pub enum Command {
-        RunCommand(OsString),
+        RunCommand(String),
         SendStdin(Vec<u8>, u64),
 
         Cd(PathBuf),
@@ -62,8 +62,9 @@ pub mod messages {
     #[derive(Serialize, Deserialize)]
     pub enum Response {
         AckRunCommand(u64),
+        SendStderr(Vec<u8>, u64, u64),
         SendStdout(Vec<u8>, u64, u64),
-        CommandDone(u64),
+        CommandDone(u64, u32),
 
         CdDone,
         LsResults(Vec<DirEntry>),

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