let is_bio = self.is_bio_mode();

let data: &[u8] = data_bytes.as_ref();

// Write data in chunks to avoid filling the internal TLS buffer

// rustls has a limited internal buffer, so we need to flush periodically

const CHUNK_SIZE: usize = 16384; // 16KB chunks (typical TLS record size)

let mut written = 0;

while written < data.len() {

let chunk_end = std::cmp::min(written + CHUNK_SIZE, data.len());

let chunk = &data[written..chunk_end];

// Write chunk to TLS layer

{

let mut writer = conn.writer();

use std::io::Write;

writer

.write_all(chunk)

.map_err(|e| vm.new_os_error(format!("Write failed: {e}")))?;

}

written = chunk_end;

// Flush TLS data to socket after each chunk

if conn.wants_write() {

if is_bio {

self.write_pending_tls(conn, vm)?;

} else {

// Socket mode: flush all pending TLS data

while conn.wants_write() {

let mut buf = Vec::new();

conn.write_tls(&mut buf)

.map_err(|e| vm.new_os_error(format!("TLS write failed: {e}")))?;

if !buf.is_empty() {

let timed_out =

self.sock_wait_for_io_impl(SelectKind::Write, vm)?;

if timed_out {

return Err(vm.new_os_error("Write operation timed out"));

}

match self.sock_send(buf, vm) {

Ok(_) => {}

Err(e) => {

if is_blocking_io_error(&e, vm) {

return Err(create_ssl_want_write_error(vm));

}

return Err(e);

}