A send_ping method for measuring latency

The already supported send_keepalive method is useful for keeping the
connection alive, but when the application wants to measure the latency,
we need to wait for the response before returning.

Author: moshevds

russh/src/client/encrypted.rs

@@ -744,6 +744,9 @@ impl Session {
                     Some(GlobalRequestResponse::Keepalive) => {
                         // ignore keepalives
                     }
+                    Some(GlobalRequestResponse::Ping(return_channel)) => {
+                        let _ = return_channel.send(());
+                    }
                     Some(GlobalRequestResponse::NoMoreSessions) => {
                         debug!("no-more-sessions@openssh.com requests success");
                     }
@@ -783,6 +786,9 @@ impl Session {
                     Some(GlobalRequestResponse::Keepalive) => {
                         // ignore keepalives
                     }
+                    Some(GlobalRequestResponse::Ping(return_channel)) => {
+                        let _ = return_channel.send(());
+                    }
                     Some(GlobalRequestResponse::NoMoreSessions) => {
                         warn!("no-more-sessions@openssh.com requests failure");
                     }

russh/src/client/mod.rs

@@ -200,6 +200,9 @@ pub enum Msg {
     Keepalive {
         want_reply: bool,
     },
+    Ping {
+        reply_channel: oneshot::Sender<()>,
+    },
     NoMoreSessions {
         want_reply: bool,
     },
@@ -839,6 +842,19 @@ impl<H: Handler> Handle<H> {
             .map_err(|_| Error::SendError)
     }
 
+    /// Send a keepalive/ping package to the remote peer, and wait for the reply/pong.
+    pub async fn send_ping(&self) -> Result<(), Error> {
+        let (sender, receiver) = oneshot::channel();
+        self.sender
+            .send(Msg::Ping {
+                reply_channel: sender,
+            })
+            .await
+            .map_err(|_| Error::SendError)?;
+        let _ = receiver.await;
+        Ok(())
+    }
+
     /// Send a no-more-sessions request to the remote peer.
     pub async fn no_more_sessions(&self, want_reply: bool) -> Result<(), Error> {
         self.sender
@@ -1394,6 +1410,9 @@ impl Session {
             Msg::Keepalive { want_reply } => {
                 let _ = self.send_keepalive(want_reply);
             }
+            Msg::Ping { reply_channel } => {
+                let _ = self.send_ping(reply_channel);
+            }
             Msg::NoMoreSessions { want_reply } => {
                 let _ = self.no_more_sessions(want_reply);
             }

russh/src/client/session.rs

@@ -416,6 +416,19 @@ impl Session {
         Ok(())
     }
 
+    pub fn send_ping(&mut self, reply_channel: oneshot::Sender<()>) -> Result<(), crate::Error> {
+        self.open_global_requests
+            .push_back(crate::session::GlobalRequestResponse::Ping(reply_channel));
+        if let Some(ref mut enc) = self.common.encrypted {
+            push_packet!(enc.write, {
+                msg::GLOBAL_REQUEST.encode(&mut enc.write)?;
+                "keepalive@openssh.com".encode(&mut enc.write)?;
+                (true as u8).encode(&mut enc.write)?;
+            });
+        }
+        Ok(())
+    }
+
     pub fn no_more_sessions(&mut self, want_reply: bool) -> Result<(), crate::Error> {
         self.open_global_requests
             .push_back(crate::session::GlobalRequestResponse::NoMoreSessions);

russh/src/session.rs

@@ -582,6 +582,8 @@ pub(crate) struct NewKeys {
 pub(crate) enum GlobalRequestResponse {
     /// request was for Keepalive, ignore result
     Keepalive,
+    /// request was for Keepalive but with notification of the result
+    Ping(oneshot::Sender<()>),
     /// request was for NoMoreSessions, disallow additional sessions
     NoMoreSessions,
     /// request was for TcpIpForward, sends Some(port) for success or None for failure