r: R,

    pub r: R,
}
impl<R: AsyncRead + AsyncWrite> SshRead<R> {
    pub fn split(self) -> (SshRead<tokio::io::ReadHalf<R>>, tokio::io::WriteHalf<R>) {
        let (r, w) = tokio::io::split(self.r);
        (SshRead {
            id: self.id,
            r
        }, w)
    }

use tokio::pin;

}
async fn start_reading<R: AsyncRead + Unpin>(mut stream_read: R, mut buffer: SSHBuffer, cipher: Arc<crate::cipher::CipherPair>) -> Result<(usize, R, SSHBuffer), anyhow::Error> {
    buffer.buffer.clear();
    let n = cipher::read(&mut stream_read, &mut buffer, &cipher).await?;
    Ok((n, stream_read, buffer))

    let mut buffer = SSHBuffer::new();

    let (stream_read, mut stream_write) = stream.split();
    let buffer = SSHBuffer::new();
    let reading = start_reading(stream_read, buffer, session.common.cipher.clone());
    pin!(reading);

            _ = cipher::read(&mut stream, &mut buffer, &session.common.cipher) => {

            Ok((_, stream_read, buffer)) = &mut reading => {

                reading.set(start_reading(stream_read, buffer, session.common.cipher.clone()));

        stream

        stream_write

        buffer.buffer.clear();

    stream.shutdown().await?;
    buffer.buffer.clear();
    while cipher::read(&mut stream, &mut buffer, &session.common.cipher).await? != 0 {
        buffer.buffer.clear();

    stream_write.shutdown().await?;
    loop {
        let (n, r, b) = (&mut reading).await?;
        if n == 0 {
            break
        } else {
            reading.set(start_reading(r, b, session.common.cipher.clone()))
        }

use tokio::pin;

async fn start_reading<R: AsyncRead + Unpin>(mut stream_read: R, mut buffer: SSHBuffer, cipher: Arc<crate::cipher::CipherPair>) -> Result<(usize, R, SSHBuffer), anyhow::Error> {
    buffer.buffer.clear();
    let n = cipher::read(&mut stream_read, &mut buffer, &cipher).await?;
    Ok((n, stream_read, buffer))
}

        mut stream: R,

        mut stream: SshRead<R>,

        let mut buffer = SSHBuffer::new();

        let (stream_read, mut stream_write) = stream.split();
        let buffer = SSHBuffer::new();
        let reading = start_reading(stream_read, buffer, self.common.cipher.clone());
        pin!(reading);

                n = cipher::read(&mut stream, &mut buffer, &self.common.cipher) => {
                    if n.is_err() || buffer.buffer.len() < 5 {

                Ok((_, stream_read, buffer)) = &mut reading => {
                    if buffer.buffer.len() < 5 {

                    reading.set(start_reading(stream_read, buffer, self.common.cipher.clone()));

                stream.write_all(&self.common.write_buffer.buffer).await?;
                stream.flush().await?;

                stream_write.write_all(&self.common.write_buffer.buffer).await?;
                stream_write.flush().await?;

            buffer.buffer.clear();

            stream.shutdown().await?;
            // Shutdown
            buffer.buffer.clear();
            while cipher::read(&mut stream, &mut buffer, &self.common.cipher).await? != 0 {
                buffer.buffer.clear();
            }

            stream_write.shutdown().await?;