Try fix block

Author: vkill

async-ssh2-lite/src/session_stream/impl_async_io.rs

@@ -6,7 +6,10 @@ use std::io::{Error as IoError, ErrorKind as IoErrorKind};
 
 use async_io::{Async, Timer};
 use async_trait::async_trait;
-use futures_util::{future, pin_mut, ready};
+use futures_util::{
+    future::{self, Either},
+    pin_mut, ready,
+};
 use ssh2::{BlockDirections, Error as Ssh2Error, Session};
 
 use super::{AsyncSessionStream, BlockDirectionsExt as _};
@@ -53,10 +56,14 @@ where
                     assert!(expected_block_directions.is_readable());
                     assert!(expected_block_directions.is_writable());
 
-                    let (ret, _) = future::select(self.readable(), self.writable())
+                    let (ret, either) = future::select(self.readable(), self.writable())
                         .await
                         .factor_first();
-                    ret?
+                    ret?;
+                    match either {
+                        Either::Left(_) => self.writable().await?,
+                        Either::Right(_) => self.readable().await?,
+                    }
                 }
             }
 

async-ssh2-lite/src/session_stream/impl_tokio.rs

@@ -52,8 +52,22 @@ impl AsyncSessionStream for TcpStream {
                     assert!(expected_block_directions.is_readable());
                     assert!(expected_block_directions.is_writable());
 
-                    self.ready(tokio::io::Interest::READABLE | tokio::io::Interest::WRITABLE)
-                        .await?;
+                    loop {
+                        let ready = self
+                            .ready(tokio::io::Interest::READABLE | tokio::io::Interest::WRITABLE)
+                            .await?;
+                        if ready.is_readable() {
+                            self.writable().await?;
+                            break;
+                        } else if ready.is_writable() {
+                            self.readable().await?;
+                            break;
+                        } else if ready.is_empty() {
+                            continue;
+                        } else {
+                            break;
+                        }
+                    }
                 }
             }
 
@@ -152,8 +166,22 @@ impl AsyncSessionStream for UnixStream {
                     assert!(expected_block_directions.is_readable());
                     assert!(expected_block_directions.is_writable());
 
-                    self.ready(tokio::io::Interest::READABLE | tokio::io::Interest::WRITABLE)
-                        .await?;
+                    loop {
+                        let ready = self
+                            .ready(tokio::io::Interest::READABLE | tokio::io::Interest::WRITABLE)
+                            .await?;
+                        if ready.is_readable() {
+                            self.writable().await?;
+                            break;
+                        } else if ready.is_writable() {
+                            self.readable().await?;
+                            break;
+                        } else if ready.is_empty() {
+                            continue;
+                        } else {
+                            break;
+                        }
+                    }
                 }
             }