HTTP/2 103 Early Hints Support #3991

apu031 · 2025-12-09T12:59:54Z

Implement HTTP/2 103 Early Hints Support

Add complete HTTP/2 103 Early Hints implementation with full client and server support, building upon the initial 1xx informational responses prototype to deliver a solution for web performance optimization.

Key Features Added

Client-side Support

Add InformationalConfig with callback system for processing 1xx informational responses
Extend HTTP/2 client builder with informational_responses() configuration method
Implement informational response polling in h2 client task with callback invocation
Support real-time processing of 103 Early Hints and other informational responses
Handle multiple informational responses before final response arrives

Server-side Support

Add InformationalSender extension for server-side hint transmission via mpsc channel
Implement server-side informational response forwarding using h2's send_informational API
Support multiple 103 Early Hints responses per request for progressive resource discovery
Validate informational responses and handle errors gracefully
Extend HTTP/1 informational support from initial prototype to HTTP/2

Complete Implementation

Build upon Joel Dice's initial HTTP/1 prototype (commit 4e2483a) to add full HTTP/2 support
Integrate with h2 crate's informational response capabilities
Add robust error handling and validation
Include production-ready example with TLS, resource preloading, and performance monitoring
Provide extensive test coverage with 11 integration tests covering different scenarios

Changed Files

Cargo.toml: Example build configuration
examples/README.md: Document new HTTP/2 Early Hints example
examples/http2_early_hints.rs: Working example with TLS, and resource preloading
src/client/conn/http2.rs: Extend HTTP/2 client builder with informational response configuration
src/client/conn/informational.rs: New module implementing client-side informational callback system
src/client/conn/mod.rs: Export new informational module
src/proto/h1/dispatch.rs: Update HTTP/1 dispatch for informational compatibility
src/proto/h1/role.rs: Extend HTTP/1 role handling for informational responses
src/proto/h2/client.rs: HTTP/2 client informational response polling
src/proto/h2/server.rs: HTTP/2 server informational response forwarding
tests/integration-early-hints.rs: 11 integration tests covering:
- Basic preconnect hints functionality
- Resource preloading (CSS, JS, fonts, images)
- Content Security Policy enforcement via Early Hints
- Multiple sequential 103 responses
- Mixed Link header types with HTTP/2 compression handling
- Cross-origin redirect security behavior
- Real-world web page optimization scenarios
- Empty 103 response validation
- Timing validation for performance benefits
- Error response handling after hints sent

Use Cases Supported

103 Early Hints: Enable early resource discovery and preloading for web performance optimization
100 Continue: Support request/response optimization for large payloads
Resource Preloading: CSS, JavaScript, fonts, images, and fetch resources
CDN Preconnection: Early connection establishment to external domains
Progressive Enhancement: Multiple hint responses as server processing progresses

Technical Implementation

Informational responses sent without END_STREAM flag to maintain connection
Stream state management preserves HTTP/2 flow control during informational responses
Client callback system separates informational processing from main response flow
Server extension system allows middleware and applications to send hints seamlessly
Cross-origin security validated for redirect scenarios
Backward compatibility maintained - existing code continues to work unchanged

Standards Compliance

RFC 8297: Complete HTTP Status Code 103 Early Hints implementation
RFC 7540: HTTP/2 specification compliance for informational responses
HTTP/2 HPACK: Proper header compression handling for multiple Link headers
Browser Security: Cross-origin redirect protection and validation

Browser Tests

Chrome:

Firefox:

The implementation provides a robust foundation for web performance optimization while maintaining the reliability and safety expected from the hyper HTTP library.

Resolves #3980 and #2426 for HTTP/2 103 Early Hints support and extends the informational responses capability for HTTP/2 protocols.

apu031 · 2025-12-09T13:18:40Z

Hello @dicej , @pablocm, @vikanezrimaya, @nox, @seanmonstar!

My commit originally builds on @dicej's prototype commit 4e2483a in PR - #3815. However, this code is obsolete and does not build anymore. Therefore, I have included both the commits in my PR. @seanmonstar @nox let me know if this would be the right way to move forward.

The code changes follow the proposed public API suggested from @vikanezrimaya. After merging this, I will release a PR for Axum wrapper.

Note - The tests will pass once we merge the h2 repo's PR - hyperium/h2#865

Thank you very much once again for your time and support. 🙏🏼

This is a prototype intended to spur discussion about what support for 1xx informational responses should look like in a Hyper server. The good news is that it works great (for HTTP/1 only, so far). The bad news is it's kind of ugly. Here's what I did: - Add `ext::InformationalSender`, a type which wraps a `futures_channel::mspc::Sender<Response<()>>`. This may be added as an extension to an inbound `Request` by the Hyper server, and the application and/or middleware may use it to send one or more informational responses before sending the real one. - Add code to `proto::h1::dispatch` and friends to add such an extension to each inbound request and then poll the `Receiver` end along with the future representing the final response. If the app never sends any informational responses, then everything proceeds as normal. Otherwise, we send those responses as they become available until the final response is ready. TODO items: - [ ] Also support informational responses in the HTTP/2 server. - [ ] Determine best way to handle when the app sends an informational response with a non-1xx status code. Currently we just silently ignore it. - [ ] Come up with a less hacky API? - [ ] Add test coverage. Signed-off-by: Joel Dice <joel.dice@fermyon.com>

Add complete HTTP/2 103 Early Hints implementation with client and server support: - Add InformationalSender extension for server-side hint transmission via mpsc channel - Create InformationalCallback system for client-side informational response handling - Extend HTTP/2 client builder with informational_responses() configuration method - Implement informational response polling in h2 client task with callback invocation - Add server-side informational response forwarding using h2's send_informational API - Include extensive integration tests covering multiple scenarios and edge cases - Add complete working example with TLS, resource preloading, and performance monitoring - Update Cargo.toml with local h2 dependency and example build configuration The implementation enables servers to send resource preload hints before final responses, allowing browsers to start downloading critical resources early and improve page load performance. Clients can register callbacks to process 103 Early Hints and other informational responses. Closes hyperium#3980, hyperium#2426

JakubKoralewski

Hi, I'm interested in 10x support so thought I'd contribute a review. Thanks for this work. I am not a contributor just hope to make it easier to review for someone in charge.

JakubKoralewski · 2026-01-21T15:10:46Z

src/proto/h2/server.rs

 use http::{Method, Request};
 use pin_project_lite::pin_project;

+#[cfg(feature = "server")]


i think src/proto/h2/mod.rs already makes sure this whole file is #[cfg(server)] (applies to all instances of #[cfg(feature)] in this file)

JakubKoralewski · 2026-01-21T15:25:46Z

src/proto/h2/server.rs

                        }

+                        #[cfg(feature = "server")]
+                        let (informational_tx, informational_rx) = mpsc::channel(10);


informational_pusher will solve this:

this creates a new channel for each call to .poll_server, doesn't seem right, no?
looks like mpsc::channel does not allocate the whole bounded_size, but it does create a bunch (>=3) Boxes,

once informational_pusher is used, and if contributors agree to add a crate it might be worth to consider https://docs.rs/thingbuf/latest/thingbuf/struct.StaticThingBuf.html

JakubKoralewski · 2026-01-21T15:32:20Z

Cargo.toml

 tokio-test = "0.4"
 tokio-util = "0.7.10"
+# Additional dependencies for HTTP/2 Early Hints example
+rcgen = "0.12"


in [dependencies]: maybe make it clear that 0.4.13 is required for "h2" crate?

JakubKoralewski · 2026-01-21T16:26:10Z

examples/http2_early_hints.rs

+                    // API data (lower priority - dynamic content)
+                    .header(
+                        "link",
+                        "</api/initial-data.json>; rel=preload; as=fetch; crossorigin",


nit; isn't this a misuse of preloading if data is not needed to display above-fold-content?

JakubKoralewski · 2026-01-21T16:44:34Z

src/proto/h2/server.rs

+                        #[cfg(feature = "server")]
+                        {
+                            req.extensions_mut()
+                                .insert(InformationalSender(informational_tx));


what if the user does not care about their server supporting 10x? should this Sender still be created?

you should probably use the API accepted by @seanmonstar, i.e. this: https://gist.github.com/vikanezrimaya/037101dc7b28de37ef03a47569213236#api-based-on-the-old-server-push-proposal (linked to title api-based-on-the-old-server-push-proposal) (with the caveatt it should be informational_pusher not :early_hints_pusher) and then the pusher can add the extension so it only gets added when needed

(my api idea) before I saw the one based on the old server push proposal

request.provide_interim(Response::builder().status(StatusCode::EARLY_HINTS).body(()).unwrap());

where implementation is this Rusty-pseudocode:

trait HttpRequestExtInterim { fn provide_interim(&mut self, hints: Response<()>) -> TrySendError<Response<()>> { let request = self; let (rx, tx) = mpsc::channel(10); // or something non-allocating? request.extensions_mut().insert(InformationalSender(tx)); tx.try_send(hints) } }

because the extension needs to be on the Request before the call to H2Stream, I'm guessing in the Service handler we are after?

but what if InformationalSender stored lazily both sides of the mpsc::channel with an None Option at first, and then the HttpRequestExtInterim.provide_interim actually allocated the Option only when used?

JakubKoralewski · 2026-01-21T16:55:21Z

src/proto/h2/server.rs

        loop {
+            // Check for informational responses first
+            #[cfg(feature = "server")]
+            if let Some(informational_rx) = me.informational_rx.as_mut() {


shouldn't this be in the H2StreamStateProj::Service case, i.e. no need to check for informational if we're currently streaming the Body?

apu031 mentioned this pull request Dec 10, 2025

Implement HTTP/2 informational responses (1xx) support hyperium/h2#865

Merged

apu031 force-pushed the http-103 branch from 7a6e6fc to 6810b2b Compare January 14, 2026 22:57

dicej and others added 2 commits January 14, 2026 23:04

apu031 force-pushed the http-103 branch from 6810b2b to 6aba402 Compare January 14, 2026 23:04

JakubKoralewski reviewed Jan 21, 2026

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

HTTP/2 103 Early Hints Support #3991

HTTP/2 103 Early Hints Support #3991

Uh oh!

apu031 commented Dec 9, 2025 •

edited

Loading

Uh oh!

apu031 commented Dec 9, 2025

Uh oh!

JakubKoralewski left a comment

Uh oh!

JakubKoralewski Jan 21, 2026

Uh oh!

JakubKoralewski Jan 21, 2026

Uh oh!

JakubKoralewski Jan 21, 2026

Uh oh!

JakubKoralewski Jan 21, 2026

Uh oh!

JakubKoralewski Jan 21, 2026

Uh oh!

JakubKoralewski Jan 21, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

HTTP/2 103 Early Hints Support #3991

Are you sure you want to change the base?

HTTP/2 103 Early Hints Support #3991

Uh oh!

Conversation

apu031 commented Dec 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Implement HTTP/2 103 Early Hints Support

Key Features Added

Client-side Support

Server-side Support

Complete Implementation

Changed Files

Use Cases Supported

Technical Implementation

Standards Compliance

Browser Tests

Uh oh!

apu031 commented Dec 9, 2025

Uh oh!

JakubKoralewski left a comment

Choose a reason for hiding this comment

Uh oh!

JakubKoralewski Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

JakubKoralewski Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

JakubKoralewski Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

JakubKoralewski Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

JakubKoralewski Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

JakubKoralewski Jan 21, 2026

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

apu031 commented Dec 9, 2025 •

edited

Loading