Hacktoberfest 2026: le issue che i maintainer hanno segnato per ottobre, aperte e adatte ai principianti. Sfoglia le issue Hacktoberfest

False `SendRequest` readiness for HTTP/1 connections

Aperta
  • Qualcosa non va?
#4,246 1 commento 0 reazioni 0 assegnatari Vedi su GitHub

I maintainer di solito rispondono entro 1 giorno

@akasakariko ci sta già lavorando.

Dal 27/10/2026.

  • #4247 di @akasakariko — aperta

Valutazione

Difficoltà
4/5
Tempo stimato
1-2 giorni
Idoneità per principianti
55/100
Tipo di issue
Bug
Chiarezza
Specificata chiaramente
Stato di attività
Attiva
Stack tecnologico
rust
Ambito
backend-api-design, networking

Direzione di ricerca

Start with the reproduction in the issue and compare the readiness behavior against hyper versions before and after 1.12. Then trace how http1::SendRequest readiness interacts with the connection dispatch queue, using #4207 and #4208 for context. Done when readiness stays pending while a request is in flight and the reproduction no longer observes immediate cancellation.

Scritto dal modello di indicizzazione a partire dal testo della issue.

Descrizione

C-bug
Version

hyper 1.12

Platform

Darwin 25.6.0

Summary

I believe to have found a readiness race in hyper 1.12 (and at the time of writing master), possibly as a result of the fix for #4207.

http1::SendRequest can signal readiness while a request is still in flight. Using it to send a request results in the request being cancelled immediately.

I have tried to conjure a minimal reproduction example in this gist. With it, you can also set the hyper dependency to <1.12 and observe that the repro test no longer detects the issue.

Code Sample
use std::future::Future;
use std::future::poll_fn;
use std::io;
use std::pin::Pin;
use std::pin::pin;
use std::task::Context;
use std::task::Poll;

use hyper::Request;
use hyper::client::conn::http1;
use hyper::rt::Read;
use hyper::rt::ReadBufCursor;
use hyper::rt::Write;

// Accept writes, but never respond or close: the first request stays in flight.
struct SilentPeer;

impl Read for SilentPeer {
    fn poll_read(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
        _: ReadBufCursor<'_>,
    ) -> Poll<io::Result<()>> {
        Poll::Pending
    }
}

impl Write for SilentPeer {
    fn poll_write(
        self: Pin<&mut Self>,
        _: &mut Context<'_>,
        buf: &[u8],
    ) -> Poll<io::Result<usize>> {
        Poll::Ready(Ok(buf.len()))
    }

    fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }

    fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> {
        Poll::Ready(Ok(()))
    }
}

#[tokio::test]
async fn successful_readiness_must_not_be_withdrawn_before_send() {
    let (mut sender, connection) = http1::handshake::<_, String>(SilentPeer).await.unwrap();
    let mut connection = pin!(connection);

    poll_fn(|cx| {
        assert!(connection.as_mut().poll(cx).is_pending());
        Poll::Ready(())
    })
    .await;
    sender.ready().await.unwrap();
    // Retain this future: dropping it would cancel the request.
    let _first = sender.send_request(Request::new(String::new()));

    poll_fn(|cx| {
        // Force the dispatch queue to report Pending despite the queued request.
        while let Poll::Ready(budget) = tokio::task::coop::poll_proceed(cx) {
            budget.made_progress();
        }
        assert!(connection.as_mut().poll(cx).is_pending());

        match sender.poll_ready(cx) {
            Poll::Pending => return Poll::Ready(()), // No false readiness: correct.
            Poll::Ready(result) => result.unwrap(),  // False readiness!
        }

        // Model the connection task running on another worker before our send.
        let mut driver = pin!(tokio::task::unconstrained(connection.as_mut()));
        assert!(driver.as_mut().poll(cx).is_pending());
        assert!(
            !sender.is_closed(),
            "the peer has not closed the connection"
        );

        let mut second = pin!(sender.send_request(Request::new(String::new())));
        let result = second.as_mut().poll(cx);
        assert!(
            !matches!(result, Poll::Ready(Err(_))),
            "send_request failed after poll_ready returned Ready(Ok(())): {result:?}"
        );
        Poll::Ready(())
    })
    .await;
}
Expected Behavior

The http1::SendRequest indicates Poll::Pending until it is ready.

Actual Behavior

The http1::SendRequest indicates Poll::Ready and the http1::SendRequest::send_request future fails immediately with an error indicating request cancellation.

Additional Context

Possibly related issues:

  • #4207

Possibly related pull requests:

  • #4208
Lingua principale
Rust
Stelle
16.4k
Fork
1.8k
Merge medio
1g 13h
PR unite (30g)
12

Preparare l'ambiente

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di hyperium/hyper

Tutte le issue di hyperium/hyper

Issue simili

Altre issue su Rust

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.