Method try_read_close_notify

crates/stdlib/src/ssl.rs:4299–4344

Helper: Try to read incoming data from socket/BIO Returns true if peer closed connection (with or without close_notify)

(
            &self,
            conn: &mut TlsConnection,
            vm: &VirtualMachine,
        )

        // Helper: Try to read incoming data from socket/BIO
        // Returns true if peer closed connection (with or without close_notify)
        fn try_read_close_notify(
            &self,
            conn: &mut TlsConnection,
            vm: &VirtualMachine,
        ) -> PyResult<bool> {
            // In socket mode, peek first to avoid consuming post-TLS cleartext
            // data. During STARTTLS, after close_notify exchange, the socket
            // transitions to cleartext. Without peeking, sock_recv may consume
            // cleartext data meant for the application after unwrap().
            if self.incoming_bio.is_none() {
                return self.try_read_close_notify_socket(conn, vm);
            }

            // BIO mode: read from incoming BIO
            match self.sock_recv(SSL3_RT_MAX_PLAIN_LENGTH, vm) {
                Ok(bytes_obj) => {
                    let bytes = ArgBytesLike::try_from_object(vm, bytes_obj)?;
                    let data = bytes.borrow_buf();

                    if data.is_empty() {
                        if let Some(ref bio) = self.incoming_bio {
                            // BIO mode: check if EOF was signaled via write_eof()
                            let bio_obj: PyObjectRef = bio.clone().into();
                            let eof_attr = bio_obj.get_attr("eof", vm)?;
                            let is_eof = eof_attr.try_to_bool(vm)?;
                            if !is_eof {
                                return Ok(false);
                            }
                        }
                        return Ok(true);
                    }

                    let data_slice: &[u8] = data.as_ref();
                    let mut cursor = std::io::Cursor::new(data_slice);
                    let _ = conn.read_tls(&mut cursor);
                    let _ = conn.process_new_packets();
                    Ok(false)
                }
                Err(e) => {
                    if is_blocking_io_error(&e, vm) {
                        return Ok(false);
                    }
                    Ok(true)
                }
            }
        }

        /// Socket-mode close_notify reader that respects TLS record boundaries.
        /// Uses MSG_PEEK to inspect data before consuming, preventing accidental