crates/stdlib/src/ssl/compat.rs (1)

1744-1782: Fix partial-write retry bug: return partial success instead of deferring to bad-write-retry check.

rustls 0.23's Writer::write() can return partial writes (accepted bytes < data.len()) when internal buffer limits are exceeded. Currently, if such a partial write occurs (line 1760) and later send_all_bytes returns WantWrite, WantRead, or Timeout (lines 1810–1828), the partial count is preserved in write_buffered_len (line 1781). On retry with the original full buffer, the condition at line 1837 (already_buffered != data.len()) incorrectly triggers a "bad write retry" error, violating OpenSSL's partial-write retry semantics.

Instead, when a partial write is followed by a WANT_* or Timeout error path, return the partial success immediately rather than attempting to re-buffer on retry:

🛠️ Suggested approach: surface partial writes on WANT_* paths

Track whether only a prefix was accepted (wrote_partial), and on WantWrite/WantRead/Timeout, return the partial count instead of deferring the retry:

         let mut bytes_written_to_rustls = 0usize;
+        let mut wrote_partial = false;
 
         if already_buffered == 0 {
             // ... write plaintext to rustls ...
             match writer.write(data) { ... }
+            wrote_partial = bytes_written_to_rustls < data.len();
             *socket.write_buffered_len.lock() = bytes_written_to_rustls;
         } else if already_buffered != data.len() {
             // bad write retry check
         }
         
         loop {
             // ... send TLS records ...
             match send_all_bytes(...) {
                 Err(SslError::WantWrite) => {
+                    if wrote_partial {
+                        *socket.write_buffered_len.lock() = 0;
+                        return Ok(bytes_written_to_rustls);
+                    }
                     return Err(SslError::WantWrite);
                 }
                 Err(SslError::WantRead) => {
+                    if wrote_partial {
+                        *socket.write_buffered_len.lock() = 0;
+                        return Ok(bytes_written_to_rustls);
+                    }
                     // ... existing logic ...
                 }
                 Err(e @ SslError::Timeout(_)) => {
+                    if wrote_partial {
+                        *socket.write_buffered_len.lock() = 0;
+                        return Ok(bytes_written_to_rustls);
+                    }
                     return Err(e);
                 }
             }
         }

(Also applies to: 1857–1871)