sans-IO

pub struct ConnectionCommon<Data> {
    pub(crate) core: ConnectionCore<Data>,
    deframer_buffer: DeframerVecBuffer,
    sendable_plaintext: ChunkVecBuffer,
}

    pub fn wants_write(&self) -> bool {
        !self.sendable_tls.is_empty()
    }

    pub fn wants_read(&self) -> bool {
        // We want to read more data all the time, except when we have unprocessed plaintext.
        // This provides back-pressure to the TCP buffers. We also don't want to read more after
        // the peer has sent us a close notification.
        //
        // In the handshake case we don't have readable plaintext before the handshake has
        // completed, but also don't want to read if we still have sendable tls.
        self.received_plaintext.is_empty()
            && !self.has_received_close_notify
            && (self.may_send_application_data || self.sendable_tls.is_empty())
    }

        let mut state = match mem::replace(&mut self.state, Err(Error::HandshakeNotComplete)) {
            Ok(state) => state,
            Err(e) => {
                self.state = Err(e.clone());
                return Err(e);
            }
        };
        // ...
            match self.process_msg(msg, state, Some(sendable_plaintext)) {
                Ok(new) => state = new,
                Err(e) => {
                    self.state = Err(e.clone());
                    deframer_buffer.discard(buffer_progress.take_discard());
                    return Err(e);
                }
            }

fn transfer(from: &mut Connection, to: &mut Connection) -> usize {
  let mut buf = Vec::new();
  while from.wants_write() {
    from.write_tls(&mut buf).unwrap();
  }
  let n = buf.len();
  let mut rd = &buf[..];
  while !rd.is_empty() {
    to.read_tls(&mut rd).unwrap();
  }
  to.process_new_packets().unwrap();
  n
}

  client after new             wants_read=false wants_write=true  is_handshaking=true
  server after new             wants_read=true  wants_write=false is_handshaking=true
round 1: client write_tls -> 236 bytes
  client                       wants_read=true  wants_write=false is_handshaking=true
  server process_new_packets -> IoState { tls_bytes_to_write: 679, plaintext_bytes_to_read: 0, peer_has_closed: false }
  server                       wants_read=false wants_write=true  is_handshaking=true
round 1: server write_tls -> 679 bytes

doc-style loop without write_tls: 1000000 iterations, wants_read never became true
  client                       wants_read=false wants_write=true  is_handshaking=true
  server (never got a byte)    wants_read=true  wants_write=false is_handshaking=true

tcp client read_tls (ClientHello never written): Err(Os { code: 35, kind: WouldBlock, message: "Resource temporarily unavailable" })
tcp server read_tls: Err(Os { code: 35, kind: WouldBlock, message: "Resource temporarily unavailable" })

server got 236 bytes via read_tls, no process_new_packets:
  server                       wants_read=true  wants_write=false is_handshaking=true
  client                       wants_read=true  wants_write=false is_handshaking=true

handshaken server reader().read before any data: Err(Kind(WouldBlock))
client produced 30044 TLS bytes for 30000 plaintext bytes
read_tls after 18437 bytes buffered: Err(Custom { kind: InvalidData, error: "message buffer full" }) / Display: message buffer full
server reader().read, still unprocessed: Err(Kind(WouldBlock))
after process_new_packets: IoState { tls_bytes_to_write: 0, plaintext_bytes_to_read: 16384, peer_has_closed: false }

client writer().write(100000 bytes) -> Ok(65536); again -> Ok(0)
client write_all(100000 bytes) -> Err(Error { kind: WriteZero, message: "failed to write whole buffer" })

    fn prepare_read(&mut self) -> Result<()> {
        // Return buffered plaintext without doing any IO: `complete_io()` does not read
        // while plaintext is buffered, so blocked writes would otherwise hide it.
        if !self.conn.received_plaintext.is_empty() {
            return Ok(());
        }

        self.complete_prior_io()?;

        // We call complete_io() in a loop since a single call may read only
        // a partial packet from the underlying transport, or may only write
        // pending TLS data (like an alert queued while processing received
        // records). A full packet is needed to get more plaintext, which we
        // must do if EOF has not been hit.
        while self.conn.wants_read() {
            let (read, written) = self.conn.complete_io(self.sock)?;
            if read == 0 && written == 0 {
                break;
            }
        }

        Ok(())
    }

client: write_all(b"ping")
  [client] sock.write 236 -> Ok(236)
  [client] sock.read  -> 679
  [client] sock.write 6 -> Ok(6)
  [client] sock.write 74 -> Ok(74)
  [client] sock.write 26 -> Ok(26)
client: read_to_end
  [client] sock.read  -> 210
  [client] sock.read  -> 0
client: read_to_end -> Err(Custom { kind: UnexpectedEof, error: "peer closed connection without sending TLS close_notify: https://docs.rs/rustls/latest/rustls/manual/_03_howto/index.html#unexpected-eof" }), got "pong"
client: error kind UnexpectedEof, Display: peer closed connection without sending TLS close_notify: https://docs.rs/rustls/latest/rustls/manual/_03_howto/index.html#unexpected-eof

round 1: server write_tls -> 679 bytes
  client process_new_packets -> IoState { tls_bytes_to_write: 80, plaintext_bytes_to_read: 0, peer_has_closed: false }
  client                       wants_read=true  wants_write=true  is_handshaking=false
  server                       wants_read=true  wants_write=false is_handshaking=true
round 2: client write_tls -> 80 bytes
  client                       wants_read=true  wants_write=false is_handshaking=false
  server process_new_packets -> IoState { tls_bytes_to_write: 184, plaintext_bytes_to_read: 0, peer_has_closed: false }
  server                       wants_read=true  wants_write=true  is_handshaking=false
round 2: server write_tls -> 184 bytes
  client process_new_packets -> IoState { tls_bytes_to_write: 0, plaintext_bytes_to_read: 0, peer_has_closed: false }
  client                       wants_read=true  wants_write=false is_handshaking=false
  server                       wants_read=true  wants_write=false is_handshaking=false