Function send_all_bytes

crates/stdlib/src/ssl/compat.rs:1014–1108

Send all bytes to socket, handling partial sends with blocking wait Loops until all bytes are sent. For blocking sockets, this will wait until all data is sent. For non-blocking sockets, returns WantWrite if no progress can be made. Optional deadline parameter allows respecting a read deadline during flush.

(
    socket: &PySSLSocket,
    buf: Vec<u8>,
    vm: &VirtualMachine,
    deadline: Option<std::time::Instant>,
)

/// if no progress can be made.
/// Optional deadline parameter allows respecting a read deadline during flush.
fn send_all_bytes(
    socket: &PySSLSocket,
    buf: Vec<u8>,
    vm: &VirtualMachine,
    deadline: Option<std::time::Instant>,
) -> SslResult<()> {
    // First, flush any previously pending TLS data with deadline
    socket
        .flush_pending_tls_output(vm, deadline)
        .map_err(SslError::Py)?;

    if buf.is_empty() {
        return Ok(());
    }

    let mut sent_total = 0;
    while sent_total < buf.len() {
        // Check deadline before each send attempt
        if let Some(dl) = deadline
            && std::time::Instant::now() >= dl
        {
            socket
                .pending_tls_output
                .lock()
                .extend_from_slice(&buf[sent_total..]);
            return Err(SslError::Timeout("The operation timed out".to_string()));
        }

        // Wait for socket to be writable before sending
        let timed_out = if let Some(dl) = deadline {
            let now = std::time::Instant::now();
            if now >= dl {
                socket
                    .pending_tls_output
                    .lock()
                    .extend_from_slice(&buf[sent_total..]);
                return Err(SslError::Timeout(
                    "The write operation timed out".to_string(),
                ));
            }
            socket
                .sock_wait_for_io_with_timeout(SelectKind::Write, Some(dl - now), vm)
                .map_err(SslError::Py)?
        } else {
            socket
                .sock_wait_for_io_impl(SelectKind::Write, vm)
                .map_err(SslError::Py)?
        };
        if timed_out {
            socket
                .pending_tls_output
                .lock()
                .extend_from_slice(&buf[sent_total..]);
            return Err(SslError::Timeout(
                "The write operation timed out".to_string(),
            ));
        }