fix bio

youknowone · youknowone · commit 56b9ede34474 · 2025-10-29T20:05:34.000+09:00
diff --git a/common/src/fileutils.rs b/common/src/fileutils.rs
@@ -494,7 +494,7 @@ pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut libc::F
 
     #[cfg(not(windows))]
     {
-        use std::os::unix::io::IntoRawFd;
+        use std::os::fd::IntoRawFd;
 
         // Convert File to raw fd
         let fd = file.into_raw_fd();
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,51 @@ 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 {
+                    return Err(std::io::Error::other("BIO write failed"));
+                }
+                Ok(nbytes as usize)
+            }
         }
 
         fn flush(&mut self) -> std::io::Result<()> {
+            // MemoryBIO doesn't need flushing
             Ok(())
         }
     }
@@ -2663,9 +2669,6 @@ mod _ssl {
     unsafe extern "C" {
         // X509_check_ca returns 1 for CA certificates, 0 otherwise
         fn X509_check_ca(x: *const sys::X509) -> libc::c_int;
-
-        // BIO_up_ref increments the reference count of a BIO
-        fn BIO_up_ref(bio: *mut sys::BIO) -> libc::c_int;
     }
 
     unsafe extern "C" {

Original file line number	Diff line number	Diff line change
`@@ -494,7 +494,7 @@ pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut libc::F`
`494`	`494`
`495`	`495`	`#[cfg(not(windows))]`
`496`	`496`	`{`
`497`		`- use std::os::unix::io::IntoRawFd;`
	`497`	`+ use std::os::fd::IntoRawFd;`
`498`	`498`
`499`	`499`	`// Convert File to raw fd`
`500`	`500`	`let fd = file.into_raw_fd();`