Add a hook-trigger to the handler.

russh/examples/echoserver.rs

@@ -76,6 +76,7 @@ impl server::Server for Server {
 
 impl server::Handler for Server {
     type Error = russh::Error;
+    type Data = ();
 
     async fn channel_open_session(
         &mut self,

russh/examples/echoserver_certificates.rs

@@ -109,6 +109,7 @@ impl server::Server for Server {
 
 impl server::Handler for Server {
     type Error = russh::Error;
+    type Data = ();
 
     async fn channel_open_session(
         &mut self,

russh/examples/ratatui_app.rs

@@ -143,6 +143,7 @@ impl Server for AppServer {
 
 impl Handler for AppServer {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn channel_open_session(
         &mut self,

russh/examples/ratatui_shared_app.rs

@@ -145,6 +145,7 @@ impl Server for AppServer {
 
 impl Handler for AppServer {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn channel_open_session(
         &mut self,

russh/examples/sftp_server.rs

@@ -41,6 +41,7 @@ impl SshSession {
 
 impl russh::server::Handler for SshSession {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn auth_password(&mut self, user: &str, password: &str) -> Result<Auth, Self::Error> {
         info!("credentials: {user}, {password}");

russh/examples/test.rs

@@ -47,6 +47,7 @@ impl server::Server for Server {
 
 impl server::Handler for Server {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn channel_open_session(
         &mut self,

russh/src/client/test.rs

@@ -34,6 +34,7 @@ mod tests {
 
     impl ServerHandler for TestServer {
         type Error = Error;
+        type Data = ();
 
         async fn channel_open_session(
             &mut self,

russh/src/server/encrypted.rs

@@ -225,6 +225,7 @@ mod tests {
 
         impl Handler for Probe {
             type Error = Error;
+            type Data = ();
 
             async fn auth_publickey_offered(
                 &mut self,
@@ -426,6 +427,7 @@ mod tests {
 
         impl Handler for Probe {
             type Error = Error;
+            type Data = ();
 
             async fn auth_publickey_offered(
                 &mut self,
@@ -526,6 +528,7 @@ mod tests {
 
     impl Handler for ChannelCallbackProbe {
         type Error = Error;
+        type Data = ();
 
         async fn exec_request(
             &mut self,

russh/src/server/mod.rs

@@ -214,6 +214,7 @@ impl Auth {
 #[cfg_attr(feature = "async-trait", async_trait::async_trait)]
 pub trait Handler: Sized {
     type Error: From<crate::Error> + Send;
+    type Data: Send;
 
     /// Check authentication using the "none" method.
     ///
@@ -849,6 +850,58 @@ pub trait Handler: Sized {
             Ok(Some(best_group.clone()))
         }
     }
+
+    /// Called when the handler needs to be updated.
+    /// ['trigger'] should be used with ['process']
+    ///
+    /// # Cancel safety
+    ///
+    /// The safety of this method depends entirely on how you implement it;
+    /// it provides no inherent security guarantees.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use tokio::sync::mpsc::Receiver;
+    /// use russh::server::{Handler, Session};
+    ///
+    /// struct App{
+    ///     foo: String,
+    ///     recv: Receiver<String>,
+    ///     trigger: Receiver<String>,
+    /// }
+    ///
+    /// impl Handler for App {
+    ///     type Error = russh::Error;
+    ///     type Data = String;
+    ///     async fn trigger(&mut self) -> Result<Self::Data, Self::Error> {
+    ///         match self.trigger.recv().await {
+    ///             Some(d) => Ok(d),
+    ///             None => std::future::pending().await,
+    ///         }
+    ///     }
+    ///
+    ///     async fn process(&mut self, s: Self::Data, session: &mut Session) -> Result<(), Self::Error> {
+    ///         let s = self.recv.recv().await.unwrap();
+    ///         self.foo = s;
+    ///         Ok(())
+    ///     }
+    /// }
+    /// ```
+    ///
+    fn trigger(&mut self) -> impl Future<Output = Result<Self::Data, Self::Error>> + Send {
+        std::future::pending()
+    }
+
+    /// Called after [`trigger`], See [`trigger`] for more.
+    #[allow(unused_variables)]
+    fn process(
+        &mut self,
+        data: Self::Data,
+        session: &mut Session,
+    ) -> impl Future<Output = Result<(), Self::Error>> + Send {
+        async { Ok(()) }
+    }
 }
 
 pub struct RunningServerHandle {

russh/src/server/session.rs

@@ -746,6 +746,13 @@ impl Session {
                     }
                     reading.set(start_reading(stream_read, buffer, opening_cipher));
                 }
+                t = handler.trigger() => {
+                    debug!("handler trigger is invoked");
+                    match t {
+                        Ok(d) => handler.process(d,&mut self).await?,
+                        Err(e) => return Err(e)
+                    }
+                }
                 () = &mut keepalive_timer => {
                     self.common.alive_timeouts = self.common.alive_timeouts.saturating_add(1);
                     if self.common.config.keepalive_max != 0 && self.common.alive_timeouts > self.common.config.keepalive_max {
@@ -1515,6 +1522,7 @@ mod tests {
 
     impl crate::server::Handler for TestHandler {
         type Error = crate::Error;
+        type Data = ();
     }
 
     fn authenticated_session() -> Session {

russh/src/tests.rs

@@ -110,6 +110,7 @@ mod compress {
 
     impl server::Handler for Server {
         type Error = super::Error;
+        type Data = ();
 
         async fn channel_open_session(
             &mut self,
@@ -289,6 +290,7 @@ mod channels {
 
         impl server::Handler for ServerHandle {
             type Error = crate::Error;
+            type Data = ();
 
             async fn auth_publickey(
                 &mut self,
@@ -360,6 +362,7 @@ mod channels {
 
         impl server::Handler for ServerHandle {
             type Error = crate::Error;
+            type Data = ();
 
             async fn auth_publickey(
                 &mut self,
@@ -446,6 +449,7 @@ mod channels {
 
         impl server::Handler for ServerHandle {
             type Error = crate::Error;
+            type Data = ();
 
             async fn auth_publickey(
                 &mut self,
@@ -532,6 +536,7 @@ mod channels {
 
         impl server::Handler for ServerHandle {
             type Error = crate::Error;
+            type Data = ();
 
             async fn auth_publickey(
                 &mut self,
@@ -614,6 +619,7 @@ mod channels {
 
         impl server::Handler for ServerHandle {
             type Error = crate::Error;
+            type Data = ();
 
             async fn auth_publickey(
                 &mut self,
@@ -755,6 +761,7 @@ mod server_kex_junk {
 
     impl server::Handler for Server {
         type Error = super::Error;
+        type Data = ();
     }
 }
 
@@ -1206,6 +1213,7 @@ pub(crate) mod raw_no_crypto {
 
     impl server::Handler for MalformedInputServer {
         type Error = Error;
+        type Data = ();
 
         async fn auth_none(&mut self, _user: &str) -> Result<server::Auth, Self::Error> {
             self.record("auth_none");
@@ -1409,6 +1417,7 @@ mod future_certificate {
 
             impl server::Handler for CertHandler {
                 type Error = crate::Error;
+                type Data = ();
 
                 async fn auth_publickey_offered(
                     &mut self,

russh/tests/auth_state_reset.rs

@@ -21,6 +21,7 @@ struct RemainingMethodsUserSwitchServer;
 
 impl server::Handler for RemainingMethodsUserSwitchServer {
     type Error = russh::Error;
+    type Data = ();
 
     async fn auth_none(&mut self, user: &str) -> Result<server::Auth, Self::Error> {
         if user == "alice" {

russh/tests/test_backpressure.rs

@@ -174,6 +174,7 @@ impl russh::server::Server for Server {
 
 impl russh::server::Handler for Server {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,
@@ -242,6 +243,7 @@ impl russh::server::Server for HandleBackpressureServer {
 
 impl russh::server::Handler for HandleBackpressureServer {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_contention.rs

@@ -125,6 +125,7 @@ impl russh::server::Server for Server {
 
 impl russh::server::Handler for Server {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_data_stream.rs

@@ -183,6 +183,7 @@ impl russh::server::Server for Server {
 
 impl russh::server::Handler for Server {
     type Error = anyhow::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_kex_shared_secret.rs

@@ -360,6 +360,7 @@ struct TestServer {}
 
 impl server::Handler for TestServer {
     type Error = russh::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_max_channel_packet_size.rs

@@ -160,6 +160,7 @@ struct EchoServer {}
 
 impl server::Handler for EchoServer {
     type Error = russh::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_mlkem_kex.rs

@@ -330,6 +330,7 @@ struct TestServer {}
 
 impl server::Handler for TestServer {
     type Error = russh::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_rekey_strict_kex.rs

@@ -116,6 +116,7 @@ struct TestServer {}
 // Insecure server that accepts any public key and echos back data it receives; ONLY FOR TESTS
 impl server::Handler for TestServer {
     type Error = russh::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,

russh/tests/test_server_cert.rs

@@ -222,6 +222,7 @@ struct TestServer {}
 
 impl server::Handler for TestServer {
     type Error = russh::Error;
+    type Data = ();
 
     async fn auth_publickey(
         &mut self,