start client

ssh/Cargo.toml

@@ -4,3 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+ssh-protocol = { path = "../ssh-protocol" }
+ssh-transport = { path = "../ssh-transport" }
+clap = { version = "4.5.15", features = ["derive"] }
+eyre = "0.6.12"
+rand = "0.8.5"
+tokio = { version = "1.39.2", features = ["full"] }
+tracing-subscriber = { version = "0.3.18", features = ["json", "env-filter"] }
+
+tracing.workspace = true

ssh/src/main.rs

@@ -1,3 +1,80 @@
-fn main() {
-    println!("Hello, world!");
+use clap::Parser;
+
+use eyre::Context;
+use rand::RngCore;
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::TcpStream,
+};
+use tracing::{info, trace};
+
+use ssh_protocol::{
+    transport::{self},
+    SshStatus,
+};
+use tracing_subscriber::EnvFilter;
+
+struct ThreadRngRand;
+impl ssh_protocol::transport::SshRng for ThreadRngRand {
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        rand::thread_rng().fill_bytes(dest);
+    }
+}
+
+#[derive(clap::Parser, Debug)]
+struct Args {
+    #[arg(short = 'p', long, default_value_t = 22)]
+    port: u16,
+    destination: String,
+    command: Vec<String>,
+}
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    let args = Args::parse();
+
+    let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+    tracing_subscriber::fmt().with_env_filter(env_filter).init();
+
+    let mut conn = TcpStream::connect(&format!("{}:{}", args.destination, args.port))
+        .await
+        .wrap_err("connecting")?;
+
+    let mut state = transport::client::ClientConnection::new(ThreadRngRand);
+
+    let mut buf = [0; 1024];
+
+    loop {
+        while let Some(msg) = state.next_msg_to_send() {
+            trace!("Writing packet {msg:?}");
+            conn.write_all(&msg.to_bytes())
+                .await
+                .wrap_err("writing response")?;
+        }
+
+        let read = conn
+            .read(&mut buf)
+            .await
+            .wrap_err("reading from connection")?;
+        if read == 0 {
+            info!("Did not read any bytes from TCP stream, EOF");
+            return Ok(());
+        }
+
+        if let Err(err) = state.recv_bytes(&buf[..read]) {
+            match err {
+                SshStatus::ClientError(err) => {
+                    info!(?err, "disconnecting client after invalid operation");
+                    return Ok(());
+                }
+                SshStatus::ServerError(err) => {
+                    return Err(err);
+                }
+                SshStatus::Disconnect => {
+                    info!("Received disconnect from client");
+                    return Ok(());
+                }
+            }
+        }
+    }
 }