fix bio

youknowone · youknowone · commit ea0d2422e1aa · 2025-10-29T19:58:34.000+09:00
diff --git a/stdlib/src/ssl.rs b/stdlib/src/ssl.rs
@@ -1632,20 +1632,7 @@ mod _ssl {
                 }
             }
 
-            // Set BIOs using SSL_set_bio
-            // BIOs are reference counted and SSL_set_bio borrows our reference
-            // To prevent double free, we need to increment the reference count
-            unsafe {
-                let inbio_ptr = args.incoming.bio;
-                let outbio_ptr = args.outgoing.bio;
-
-                // Increment reference counts
-                BIO_up_ref(inbio_ptr);
-                BIO_up_ref(outbio_ptr);
-
-                // Set BIOs on SSL object
-                sys::SSL_set_bio(ssl.as_ptr(), inbio_ptr, outbio_ptr);
-            }
+            // Don't use SSL_set_bio - let SslStream drive I/O through BioStream Read/Write
 
             // Configure post-handshake authentication (PHA)
             #[cfg(ossl111)]
@@ -1672,8 +1659,8 @@ mod _ssl {
 
             // Create a BioStream wrapper (dummy, actual IO goes through BIOs)
             let bio_stream = BioStream {
-                _inbio: args.incoming,
-                _outbio: args.outgoing,
+                inbio: args.incoming,
+                outbio: args.outgoing,
             };
 
             // Create SslStream with BioStream
@@ -1841,32 +1828,55 @@ mod _ssl {
 
     // BIO stream wrapper to implement Read/Write traits for MemoryBIO
     struct BioStream {
-        _inbio: PyRef<PySslMemoryBio>,
-        _outbio: PyRef<PySslMemoryBio>,
+        inbio: PyRef<PySslMemoryBio>,
+        outbio: PyRef<PySslMemoryBio>,
     }
 
     impl Read for BioStream {
-        fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
-            // BIO mode doesn't use actual IO - data is transferred via MemoryBIO
-            // This should never be called as SSL will directly use the BIOs
-            Err(std::io::Error::new(
-                std::io::ErrorKind::Unsupported,
-                "BIO mode doesn't support direct read",
-            ))
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            // Read from incoming MemoryBIO
+            unsafe {
+                let nbytes = sys::BIO_read(
+                    self.inbio.bio,
+                    buf.as_mut_ptr() as *mut _,
+                    buf.len().min(i32::MAX as usize) as i32,
+                );
+                if nbytes < 0 {
+                    // BIO_read returns -1 on error or when no data is available
+                    // Check if it's a retry condition (WANT_READ)
+                    Err(std::io::Error::new(
+                        std::io::ErrorKind::WouldBlock,
+                        "BIO has no data available",
+                    ))
+                } else {
+                    Ok(nbytes as usize)
+                }
+            }
         }
     }
 
     impl Write for BioStream {
-        fn write(&mut self, _buf: &[u8]) -> std::io::Result<usize> {
-            // BIO mode doesn't use actual IO - data is transferred via MemoryBIO
-            // This should never be called as SSL will directly use the BIOs
-            Err(std::io::Error::new(
-                std::io::ErrorKind::Unsupported,
-                "BIO mode doesn't support direct write",
-            ))
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            // Write to outgoing MemoryBIO
+            unsafe {
+                let nbytes = sys::BIO_write(
+                    self.outbio.bio,
+                    buf.as_ptr() as *const _,
+                    buf.len().min(i32::MAX as usize) as i32,
+                );
+                if nbytes < 0 {
+                    Err(std::io::Error::new(
+                        std::io::ErrorKind::Other,
+                        "BIO write failed",
+                    ))
+                } else {
+                    Ok(nbytes as usize)
+                }
+            }
         }
 
         fn flush(&mut self) -> std::io::Result<()> {
+            // MemoryBIO doesn't need flushing
             Ok(())
         }
     }
