Add Experimental HTTP/3 Support

.gitignore

@@ -1,3 +1,4 @@
 target
 Cargo.lock
 *.swp
+.idea

Cargo.toml

@@ -62,6 +62,9 @@ stream = ["tokio/fs", "tokio-util"]
 
 socks = ["tokio-socks"]
 
+# Experimental HTTP/3 client.
+http3 = ["rustls-tls"]
+
 # Internal (PRIVATE!) features used to aid testing.
 # Don't rely on these whatsoever. They may disappear at anytime.
 
@@ -136,6 +139,13 @@ tokio-socks = { version = "0.5.1", optional = true }
 ## trust-dns
 trust-dns-resolver = { version = "0.21", optional = true }
 
+# HTTP/3 experimental support
+h3 = { git = "https://github.com/hyperium/h3" }
+h3-quinn = { git = "https://github.com/hyperium/h3" }
+quinn = { version = "0.8", default-features = false, features = ["tls-rustls", "ring"] }
+futures-channel = "0.3"
+
+
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 env_logger = "0.8"
 hyper = { version = "0.14", default-features = false, features = ["tcp", "stream", "http1", "http2", "client", "server", "runtime"] }

examples/h3_simple.rs

@@ -0,0 +1,51 @@
+#![deny(warnings)]
+
+// This is using the `tokio` runtime. You'll need the following dependency:
+//
+// `tokio = { version = "1", features = ["full"] }`
+#[cfg(feature = "http3")]
+#[cfg(not(target_arch = "wasm32"))]
+#[tokio::main]
+async fn main() -> Result<(), reqwest::Error> {
+    use http::Version;
+    use reqwest::{Client, IntoUrl, Response};
+
+    async fn get<T: IntoUrl + Clone>(url: T) -> reqwest::Result<Response> {
+        Client::builder()
+            .http3_prior_knowledge()
+            .build()?
+            .get(url)
+            .version(Version::HTTP_3)
+            .send()
+            .await
+    }
+
+    // Some simple CLI args requirements...
+    let url = match std::env::args().nth(1) {
+        Some(url) => url,
+        None => {
+            println!("No CLI URL provided, using default.");
+            "https://hyper.rs".into()
+        }
+    };
+
+    eprintln!("Fetching {:?}...", url);
+
+    let res = get(url).await?;
+
+    eprintln!("Response: {:?} {}", res.version(), res.status());
+    eprintln!("Headers: {:#?}\n", res.headers());
+
+    let body = res.text().await?;
+
+    println!("{}", body);
+
+    Ok(())
+}
+
+// The [cfg(not(target_arch = "wasm32"))] above prevent building the tokio::main function
+// for wasm32 target, because tokio isn't compatible with wasm32.
+// If you aren't building for wasm32, you don't need that line.
+// The two lines below avoid the "'main' function not found" error when building for wasm32 target.
+#[cfg(any(target_arch = "wasm32", not(feature = "http3")))]
+fn main() {}

src/async_impl/client.rs

@@ -13,7 +13,7 @@ use http::header::{
 };
 use http::uri::Scheme;
 use http::Uri;
-use hyper::client::ResponseFuture;
+use hyper::client::ResponseFuture as HyperResponseFuture;
 #[cfg(feature = "native-tls-crate")]
 use native_tls_crate::TlsConnector;
 use pin_project_lite::pin_project;
@@ -23,7 +23,6 @@ use std::task::{Context, Poll};
 use tokio::time::Sleep;
 
 use log::{debug, trace};
-
 use super::decoder::Accepts;
 use super::request::{Request, RequestBuilder};
 use super::response::Response;
@@ -41,6 +40,8 @@ use crate::Certificate;
 #[cfg(any(feature = "native-tls", feature = "__rustls"))]
 use crate::Identity;
 use crate::{IntoUrl, Method, Proxy, StatusCode, Url};
+#[cfg(feature = "http3")]
+use crate::async_impl::h3_client::{H3Builder, H3Client, H3ResponseFuture};
 
 /// An asynchronous `Client` to make Requests with.
 ///
@@ -69,6 +70,7 @@ pub struct ClientBuilder {
 enum HttpVersionPref {
     Http1,
     Http2,
+    Http3,
     All,
 }
 
@@ -121,6 +123,8 @@ struct Config {
     error: Option<crate::Error>,
     https_only: bool,
     dns_overrides: HashMap<String, SocketAddr>,
+    #[cfg(feature = "http3")]
+    tls_enable_early_data: bool
 }
 
 impl Default for ClientBuilder {
@@ -188,6 +192,8 @@ impl ClientBuilder {
                 cookie_store: None,
                 https_only: false,
                 dns_overrides: HashMap::new(),
+                #[cfg(feature = "http3")]
+                tls_enable_early_data: false
             },
         }
     }
@@ -222,15 +228,15 @@ impl ClientBuilder {
                     if config.dns_overrides.is_empty() {
                         HttpConnector::new_gai()
                     } else {
-                        HttpConnector::new_gai_with_overrides(config.dns_overrides)
+                        HttpConnector::new_gai_with_overrides(config.dns_overrides.clone())
                     }
                 }
                 #[cfg(feature = "trust-dns")]
                 true => {
                     if config.dns_overrides.is_empty() {
                         HttpConnector::new_trust_dns()?
                     } else {
-                        HttpConnector::new_trust_dns_with_overrides(config.dns_overrides)?
+                        HttpConnector::new_trust_dns_with_overrides(config.dns_overrides.clone())?
                     }
                 }
                 #[cfg(not(feature = "trust-dns"))]
@@ -252,6 +258,9 @@ impl ClientBuilder {
                             HttpVersionPref::Http2 => {
                                 tls.request_alpns(&["h2"]);
                             }
+                            HttpVersionPref::Http3 => {
+                                unreachable!("HTTP/3 shouldn't be enabled unless the feature is")
+                            },
                             HttpVersionPref::All => {
                                 tls.request_alpns(&["h2", "http/1.1"]);
                             }
@@ -434,11 +443,19 @@ impl ClientBuilder {
                         HttpVersionPref::Http2 => {
                             tls.alpn_protocols = vec!["h2".into()];
                         }
+                        HttpVersionPref::Http3 => {
+                            tls.alpn_protocols = vec!["h3".into()];
+                        }
                         HttpVersionPref::All => {
                             tls.alpn_protocols = vec!["h2".into(), "http/1.1".into()];
                         }
                     }
 
+                    #[cfg(feature = "http3")]
+                    {
+                        tls.enable_early_data = config.tls_enable_early_data;
+                    }
+
                     Connector::new_rustls_tls(
                         http,
                         tls,
@@ -508,16 +525,25 @@ impl ClientBuilder {
             builder.http1_allow_obsolete_multiline_headers_in_responses(true);
         }
 
-        let hyper_client = builder.build(connector);
-
         let proxies_maybe_http_auth = proxies.iter().any(|p| p.maybe_has_http_auth());
 
+        #[cfg(feature = "http3")]
+        let h3_builder = {
+            let mut h3_builder = H3Builder::default();
+            h3_builder.set_local_addr(config.local_address);
+            h3_builder.set_pool_idle_timeout(config.pool_idle_timeout);
+            h3_builder.set_pool_max_idle_per_host(config.pool_max_idle_per_host);
+            h3_builder
+        };
+
         Ok(Client {
             inner: Arc::new(ClientRef {
                 accepts: config.accepts,
                 #[cfg(feature = "cookies")]
                 cookie_store: config.cookie_store,
-                hyper: hyper_client,
+                #[cfg(feature = "http3")]
+                h3_client: h3_builder.build(connector.deep_clone_tls()),
+                hyper: builder.build(connector),
                 headers: config.headers,
                 redirect_policy: config.redirect_policy,
                 referer: config.referer,
@@ -914,6 +940,12 @@ impl ClientBuilder {
         self
     }
 
+    /// Only use HTTP/3.
+    pub fn http3_prior_knowledge(mut self) -> ClientBuilder {
+        self.config.http_version_pref = HttpVersionPref::Http3;
+        self
+    }
+
     /// Sets the `SETTINGS_INITIAL_WINDOW_SIZE` option for HTTP2 stream-level flow control.
     ///
     /// Default is currently 65,535 but may change internally to optimize for common uses.
@@ -1492,22 +1524,30 @@ impl Client {
 
         self.proxy_auth(&uri, &mut headers);
 
-        let mut req = hyper::Request::builder()
+        let builder = hyper::Request::builder()
             .method(method.clone())
             .uri(uri)
-            .version(version)
-            .body(body.into_stream())
-            .expect("valid request parts");
+            .version(version);
+
+        let in_flight = match version {
+            #[cfg(feature = "http3")]
+            http::Version::HTTP_3 => {
+                let mut req = builder.body(()).expect("valid request parts");
+                *req.headers_mut() = headers.clone();
+                ResponseFuture::H3(self.inner.h3_client.request(req))
+            },
+            _ => {
+                let mut req = builder.body(body.into_stream()).expect("valid request parts");
+                *req.headers_mut() = headers.clone();
+                ResponseFuture::Default(self.inner.hyper.request(req))
+            },
+        };
 
         let timeout = timeout
             .or(self.inner.request_timeout)
             .map(tokio::time::sleep)
             .map(Box::pin);
 
-        *req.headers_mut() = headers.clone();
-
-        let in_flight = self.inner.hyper.request(req);
-
         Pending {
             inner: PendingInner::Request(PendingRequest {
                 method,
@@ -1689,6 +1729,13 @@ impl Config {
         if !self.dns_overrides.is_empty() {
             f.field("dns_overrides", &self.dns_overrides);
         }
+
+        #[cfg(feature = "http3")]
+        {
+            if self.tls_enable_early_data {
+                f.field("tls_enable_early_data", &true);
+            }
+        }
     }
 }
 
@@ -1698,6 +1745,8 @@ struct ClientRef {
     cookie_store: Option<Arc<dyn cookie::CookieStore>>,
     headers: HeaderMap,
     hyper: HyperClient,
+    #[cfg(feature = "http3")]
+    h3_client: H3Client,
     redirect_policy: redirect::Policy,
     referer: bool,
     request_timeout: Option<Duration>,
@@ -1772,6 +1821,12 @@ pin_project! {
     }
 }
 
+enum ResponseFuture {
+    Default(HyperResponseFuture),
+    #[cfg(feature = "http3")]
+    H3(H3ResponseFuture),
+}
+
 impl PendingRequest {
     fn in_flight(self: Pin<&mut Self>) -> Pin<&mut ResponseFuture> {
         self.project().in_flight
@@ -1820,7 +1875,7 @@ impl PendingRequest {
 
         *req.headers_mut() = self.headers.clone();
 
-        *self.as_mut().in_flight().get_mut() = self.client.hyper.request(req);
+        *self.as_mut().in_flight().get_mut() = ResponseFuture::Default(self.client.hyper.request(req));
 
         true
     }
@@ -1877,15 +1932,30 @@ impl Future for PendingRequest {
         }
 
         loop {
-            let res = match self.as_mut().in_flight().as_mut().poll(cx) {
-                Poll::Ready(Err(e)) => {
-                    if self.as_mut().retry_error(&e) {
-                        continue;
+            let res = match self.as_mut().in_flight().get_mut() {
+                ResponseFuture::Default(r) => {
+                    match Pin::new(r).poll(cx) {
+                        Poll::Ready(Err(e)) => {
+                            if self.as_mut().retry_error(&e) {
+                                continue;
+                            }
+                            return Poll::Ready(Err(crate::error::request(e).with_url(self.url.clone())));
+                        }
+                        Poll::Ready(Ok(res)) => res,
+                        Poll::Pending => return Poll::Pending,
+                    }
+                }
+                #[cfg(feature = "http3")]
+                ResponseFuture::H3(r) => match Pin::new(r).poll(cx) {
+                    Poll::Ready(Err(e)) => {
+                        if self.as_mut().retry_error(&e) {
+                            continue;
+                        }
+                        return Poll::Ready(Err(crate::error::request(e).with_url(self.url.clone())));
                     }
-                    return Poll::Ready(Err(crate::error::request(e).with_url(self.url.clone())));
+                    Poll::Ready(Ok(res)) => res,
+                    Poll::Pending => return Poll::Pending,
                 }
-                Poll::Ready(Ok(res)) => res,
-                Poll::Pending => return Poll::Pending,
             };
 
             #[cfg(feature = "cookies")]
@@ -2001,7 +2071,7 @@ impl Future for PendingRequest {
 
                             *req.headers_mut() = headers.clone();
                             std::mem::swap(self.as_mut().headers(), &mut headers);
-                            *self.as_mut().in_flight().get_mut() = self.client.hyper.request(req);
+                            *self.as_mut().in_flight().get_mut() =  ResponseFuture::Default(self.client.hyper.request(req));
                             continue;
                         }
                         redirect::ActionKind::Stop => {