Unified test: server+client

Ignore-this: 8096940d6198b4b477ca86293b6d62b6

darcs-hash:61237c45c448d7cafad078d24bc4b4cce71063ad

Author: P-E-Meunier

src/bin/server.rs

@@ -1,74 +1,111 @@
 extern crate thrussh;
-extern crate env_logger;
 extern crate futures;
-#[macro_use]
-extern crate log;
-use std::sync::{Arc, Mutex};
+extern crate tokio_core;
+extern crate env_logger;
+use std::sync::Arc;
 use thrussh::*;
-use thrussh::server::*;
-#[derive(Debug, Clone, Default)]
-struct H(Arc<Mutex<HH>>);
-#[derive(Debug, Default)]
-struct HH {
-    user: String,
-    password: String,
-}
 
-impl thrussh::server::Handler for H {
-    type FutureAuth = futures::Finished<Auth, Error>;
+#[derive(Clone)]
+struct H{}
+
+impl server::Handler for H {
+    type FutureAuth = futures::Finished<server::Auth, Error>;
     type FutureUnit = futures::Finished<(), Error>;
     type FutureBool = futures::Finished<bool, Error>;
 
-    fn auth_password(&mut self, user: &str, password: &str) -> Self::FutureBool {
-        let mut h = self.0.lock().unwrap();
-        h.user.push_str(user);
-        h.password.clear();
-        h.password.push_str(password);
+    fn auth_publickey(&mut self, _: &str, _: &key::PublicKey) -> Self::FutureBool {
         futures::finished(true)
     }
-    fn auth_keyboard_interactive(&mut self, user: &str, _: &str, response: Option<thrussh::server::Response>) -> Self::FutureAuth {
-        println!("Keyboard interactive, user {:?}", user);
-        if let Some(resp) = response {
-
-            for resp in resp {
-                println!("resp: {:?}", resp)
-            }
-            futures::finished(Auth::Accept)
-
-        } else {
-
-            futures::finished(Auth::Partial {
-                name: "name".to_string(),
-                instructions: "type your password".to_string(),
-                prompts: vec![("Password: ".to_string(), false)]
-            })
-        }
+    fn data(&mut self, channel: ChannelId, data: &[u8], session: &mut server::Session) -> Self::FutureUnit {
+        println!("data on channel {:?}: {:?}", channel, std::str::from_utf8(data));
+        session.data(channel, None, data).unwrap();
+        futures::finished(())
     }
+}
 
-    fn auth_publickey(&mut self, user: &str, public_key: &key::PublicKey) -> Self::FutureBool {
-        debug!("publickey request by user {:?}, pub {:?}", user, public_key);
+
+use std::net::ToSocketAddrs;
+use futures::Future;
+use tokio_core::net::TcpStream;
+use tokio_core::reactor::Core;
+
+
+struct Client { }
+
+impl client::Handler for Client {
+    type FutureBool = futures::Finished<bool, Error>;
+    type FutureUnit = futures::Finished<(), Error>;
+    fn check_server_key(&mut self, server_public_key: &key::PublicKey) -> Self::FutureBool {
+        println!("check_server_key: {:?}", server_public_key);
         futures::finished(true)
     }
-    fn channel_open_session(&mut self, channel: ChannelId, session: &mut Session) -> Self::FutureUnit {
-        debug!("channel open {:?}", channel);
-        session.data(channel, None, b"Test !").unwrap();
+    fn channel_open_confirmation(&mut self, channel: ChannelId, _: &mut client::Session) -> Self::FutureUnit {
+        println!("channel_open_confirmation: {:?}", channel);
         futures::finished(())
     }
-    fn data(&mut self, channel: ChannelId, data: &[u8], session: &mut Session) -> Self::FutureUnit {
-        debug!("data on channel {:?}: {:?}", channel, std::str::from_utf8(data));
-        session.data(channel, None, data).unwrap();
+    fn data(&mut self, channel: ChannelId, ext: Option<u32>, data: &[u8], _: &mut client::Session) -> Self::FutureUnit {
+        println!("data on channel {:?} {:?}: {:?}", ext, channel, std::str::from_utf8(data));
         futures::finished(())
     }
 }
 
+impl Client {
+    fn run(self, config: Arc<client::Config>, addr: &str) {
+
+        let addr = addr.to_socket_addrs().unwrap().next().unwrap();
+        let mut l = Core::new().unwrap();
+        let handle = l.handle();
+        let done =
+            TcpStream::connect(&addr, &handle).map_err(|err| thrussh::Error::IO(err)).and_then(|socket| {
+
+                println!("connected");
+                let mut connection = client::Connection::new(
+                    config.clone(),
+                    socket,
+                    self,
+                    None
+                );
+
+                connection.set_auth_user("pe");
+                connection.set_auth_public_key(thrussh::load_secret_key("/home/pe/.ssh/id_ed25519").unwrap());
+                // debug!("connection");
+                connection.authenticate().and_then(|connection| {
+
+                    connection.channel_open_session().and_then(|(mut connection, chan)| {
+
+                        connection.data(chan, None, b"First test").unwrap();
+                        connection.data(chan, None, b"Second test").unwrap();
+                        connection.disconnect(Disconnect::ByApplication, "Ciao", "");
+                        connection
+
+                    })
+                })
+            });
+        l.run(done).unwrap();
+    }
+
+}
 
 fn main() {
     env_logger::init().unwrap();
-    let mut config = thrussh::server::Config::default();
+    // Starting the server thread.
+    let t = std::thread::spawn(|| {
+        let mut config = thrussh::server::Config::default();
+        config.connection_timeout = Some(std::time::Duration::from_secs(600));
+        config.auth_rejection_time = std::time::Duration::from_secs(3);
+        config.keys.push(thrussh::key::Algorithm::generate_keypair(thrussh::key::ED25519).unwrap());
+        let config = Arc::new(config);
+        let sh = H{};
+        thrussh::server::run(config, "0.0.0.0:2222", sh);
+    });
+
+    std::thread::sleep(std::time::Duration::from_secs(1));
+    let mut config = thrussh::client::Config::default();
     config.connection_timeout = Some(std::time::Duration::from_secs(600));
-    config.auth_rejection_time = std::time::Duration::from_secs(3);
-    config.keys.push(thrussh::load_secret_key("ssh_host_ed25519_key").unwrap());
     let config = Arc::new(config);
-    let sh = H::default();
-    thrussh::server::run(config, "0.0.0.0:2222", sh);
+    let sh = Client {};
+    sh.run(config, "127.0.0.1:2222");
+
+    // Kill the server thread after the client has ended.
+    std::mem::forget(t)
 }