Update all network-related dependencies to the latest versions (#34630)

* Update all network-related dependencies to the latest versions: * rustls * hyper * http * headers * tungstenite * async-tungstenite Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Fix panics with 1xx responses in WPT tests. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Use reported response length when calculating available ranges. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Remove unreachable match arm. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Clean up commented fragments in blob and file handlers. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Remove unreachable match arm. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Fix clippy warning. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Cleanup. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Fix up unit tests for dependency upgrades. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * Update aws-lc-sys to fix Windows builds. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * net: Use ring instead of aws-lc-sys. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * embedding: Require embedder to initialize a rustls CryptoProvider. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * Disable aws-lc-rs pending OhOS build fixes. Signed-off-by: Josh Matthews <josh@joshmatthews.net> --------- Signed-off-by: Josh Matthews <josh@joshmatthews.net>
2025-08-06 14:10:11 +01:00 · 2025-01-08 00:47:58 -05:00 · 2025-01-08 00:47:58 -05:00 · 76e0a1872b
commit 76e0a1872b
parent 270df6e263
25 changed files with 1342 additions and 1050 deletions
--- a/components/net/tests/main.rs
+++ b/components/net/tests/main.rs
@ -30,11 +30,13 @@ use crossbeam_channel::{unbounded, Sender};
 use devtools_traits::DevtoolsControlMsg;
 use embedder_traits::{EmbedderProxy, EmbedderReceiver, EventLoopWaker};
 use futures::future::ready;
-use futures::StreamExt;
-use hyper::server::conn::Http;
-use hyper::server::Server as HyperServer;
-use hyper::service::{make_service_fn, service_fn};
-use hyper::{Body, Request as HyperRequest, Response as HyperResponse};
+use http_body_util::combinators::BoxBody;
+use http_body_util::{BodyExt, Empty, Full};
+use hyper::body::{Bytes, Incoming};
+use hyper::server::conn::http1;
+use hyper::service::service_fn;
+use hyper::{Request as HyperRequest, Response as HyperResponse};
+use hyper_util::rt::tokio::TokioIo;
 use net::connector::{create_http_client, create_tls_config};
 use net::fetch::cors_cache::CorsCache;
 use net::fetch::methods::{self, CancellationListener, FetchContext};
@ -46,30 +48,26 @@ use net_traits::filemanager_thread::FileTokenCheck;
 use net_traits::request::Request;
 use net_traits::response::Response;
 use net_traits::{FetchTaskTarget, ResourceFetchTiming, ResourceTimingType};
-use rustls::{self, Certificate, PrivateKey};
 use rustls_pemfile::{certs, pkcs8_private_keys};
+use rustls_pki_types::{CertificateDer, PrivateKeyDer};
 use servo_arc::Arc as ServoArc;
 use servo_url::ServoUrl;
 use tokio::net::{TcpListener, TcpStream};
 use tokio::runtime::{Builder, Runtime};
 use tokio_rustls::{self, TlsAcceptor};
-use tokio_stream::wrappers::TcpListenerStream;
-use tokio_test::block_on;

-pub static HANDLE: LazyLock<Mutex<Runtime>> = LazyLock::new(|| {
-    Mutex::new(
-        Builder::new_multi_thread()
-            .enable_io()
-            .worker_threads(10)
-            .build()
-            .unwrap(),
-    )
+pub static HANDLE: LazyLock<Runtime> = LazyLock::new(|| {
+    Builder::new_multi_thread()
+        .enable_io()
+        .worker_threads(10)
+        .build()
+        .unwrap()
 });

 const DEFAULT_USER_AGENT: &'static str = "Such Browser. Very Layout. Wow.";

 struct FetchResponseCollector {
-    sender: Sender<Response>,
+    sender: Option<tokio::sync::oneshot::Sender<Response>>,
 }

 fn create_embedder_proxy() -> EmbedderProxy {
@ -149,6 +147,8 @@ fn receive_credential_prompt_msgs(
 }

 fn create_http_state(fc: Option<EmbedderProxy>) -> HttpState {
+    let _ = rustls::crypto::ring::default_provider().install_default();
+
    let override_manager = net::connector::CertificateErrorOverrideManager::new();
    HttpState {
        hsts_list: RwLock::new(net::hsts::HstsList::default()),
@ -197,7 +197,7 @@ impl FetchTaskTarget for FetchResponseCollector {
    fn process_response_chunk(&mut self, _: &Request, _: Vec<u8>) {}
    /// Fired when the response is fully fetched
    fn process_response_eof(&mut self, _: &Request, response: &Response) {
-        let _ = self.sender.send(response.clone());
+        let _ = self.sender.take().unwrap().send(response.clone());
    }
 }

@ -206,18 +206,22 @@ fn fetch(request: &mut Request, dc: Option<Sender<DevtoolsControlMsg>>) -> Respo
 }

 fn fetch_with_context(request: &mut Request, mut context: &mut FetchContext) -> Response {
-    let (sender, receiver) = unbounded();
-    let mut target = FetchResponseCollector { sender: sender };
-    block_on(async move {
+    let (sender, receiver) = tokio::sync::oneshot::channel();
+    let mut target = FetchResponseCollector {
+        sender: Some(sender),
+    };
+    HANDLE.block_on(async move {
        methods::fetch(request, &mut target, &mut context).await;
-        receiver.recv().unwrap()
+        receiver.await.unwrap()
    })
 }

 fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Response {
-    let (sender, receiver) = unbounded();
-    let mut target = FetchResponseCollector { sender: sender };
-    block_on(async move {
+    let (sender, receiver) = tokio::sync::oneshot::channel();
+    let mut target = FetchResponseCollector {
+        sender: Some(sender),
+    };
+    HANDLE.block_on(async move {
        methods::fetch_with_cors_cache(
            request,
            cache,
@ -225,13 +229,13 @@ fn fetch_with_cors_cache(request: &mut Request, cache: &mut CorsCache) -> Respon
            &mut new_fetch_context(None, None, None),
        )
        .await;
-        receiver.recv().unwrap()
+        receiver.await.unwrap()
    })
 }

 pub(crate) struct Server {
    pub close_channel: tokio::sync::oneshot::Sender<()>,
-    pub certificates: Option<Vec<Certificate>>,
+    pub certificates: Option<Vec<CertificateDer<'static>>>,
 }

 impl Server {
@ -242,34 +246,59 @@ impl Server {

 fn make_server<H>(handler: H) -> (Server, ServoUrl)
 where
-    H: Fn(HyperRequest<Body>, &mut HyperResponse<Body>) + Send + Sync + 'static,
+    H: Fn(HyperRequest<Incoming>, &mut HyperResponse<BoxBody<Bytes, hyper::Error>>)
+        + Send
+        + Sync
+        + 'static,
 {
    let handler = Arc::new(handler);
+
    let listener = StdTcpListener::bind("0.0.0.0:0").unwrap();
+    listener.set_nonblocking(true).unwrap();
+    let listener = HANDLE.block_on(async move { TcpListener::from_std(listener).unwrap() });
+
    let url_string = format!("http://localhost:{}", listener.local_addr().unwrap().port());
    let url = ServoUrl::parse(&url_string).unwrap();
-    let (tx, rx) = tokio::sync::oneshot::channel::<()>();
+
+    let graceful = hyper_util::server::graceful::GracefulShutdown::new();
+
+    let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();
    let server = async move {
-        HyperServer::from_tcp(listener)
-            .unwrap()
-            .serve(make_service_fn(move |_| {
-                let handler = handler.clone();
-                ready(Ok::<_, Infallible>(service_fn(
-                    move |req: HyperRequest<Body>| {
-                        let mut response = HyperResponse::new(Vec::<u8>::new().into());
-                        handler(req, &mut response);
-                        ready(Ok::<_, Infallible>(response))
-                    },
-                )))
-            }))
-            .with_graceful_shutdown(async move {
-                rx.await.ok();
-            })
-            .await
-            .expect("Could not start server");
+        loop {
+            let stream = tokio::select! {
+                stream = listener.accept() => stream.unwrap().0,
+                _val = &mut rx => {
+                    let _ = graceful.shutdown();
+                    break;
+                }
+            };
+
+            let handler = handler.clone();
+
+            let stream = stream.into_std().unwrap();
+            stream
+                .set_read_timeout(Some(std::time::Duration::new(5, 0)))
+                .unwrap();
+            let stream = TcpStream::from_std(stream).unwrap();
+
+            let http = http1::Builder::new();
+            let conn = http.serve_connection(
+                TokioIo::new(stream),
+                service_fn(move |req: HyperRequest<Incoming>| {
+                    let mut response =
+                        HyperResponse::new(Empty::new().map_err(|_| unreachable!()).boxed());
+                    handler(req, &mut response);
+                    ready(Ok::<_, Infallible>(response))
+                }),
+            );
+            let conn = graceful.watch(conn);
+            HANDLE.spawn(async move {
+                let _ = conn.await;
+            });
+        }
    };

-    HANDLE.lock().unwrap().spawn(server);
+    let _ = HANDLE.spawn(server);
    (
        Server {
            close_channel: tx,
@ -281,37 +310,40 @@ where

 /// Given a path to a file containing PEM certificates, load and parse them into
 /// a vector of RusTLS [Certificate]s.
-fn load_certificates_from_pem(path: &PathBuf) -> std::io::Result<Vec<Certificate>> {
+fn load_certificates_from_pem(path: &PathBuf) -> std::io::Result<Vec<CertificateDer<'static>>> {
    let file = File::open(path)?;
    let mut reader = BufReader::new(file);
-    let certs = certs(&mut reader)?;
-    Ok(certs.into_iter().map(Certificate).collect())
+    certs(&mut reader).collect::<Result<Vec<_>, _>>()
 }

 /// Given a path to a file containing PEM keys, load and parse them into
 /// a vector of RusTLS [PrivateKey]s.
-fn load_private_key_from_file(path: &PathBuf) -> Result<PrivateKey, Box<dyn std::error::Error>> {
+fn load_private_key_from_file(
+    path: &PathBuf,
+) -> Result<PrivateKeyDer<'static>, Box<dyn std::error::Error>> {
    let file = File::open(&path)?;
    let mut reader = BufReader::new(file);
-    let mut keys = pkcs8_private_keys(&mut reader)?;
+    let mut keys = pkcs8_private_keys(&mut reader).collect::<Result<Vec<_>, _>>()?;

    match keys.len() {
        0 => Err(format!("No PKCS8-encoded private key found in {path:?}").into()),
-        1 => Ok(PrivateKey(keys.remove(0))),
+        1 => Ok(PrivateKeyDer::try_from(keys.remove(0))?),
        _ => Err(format!("More than one PKCS8-encoded private key found in {path:?}").into()),
    }
 }

 fn make_ssl_server<H>(handler: H) -> (Server, ServoUrl)
 where
-    H: Fn(HyperRequest<Body>, &mut HyperResponse<Body>) + Send + Sync + 'static,
+    H: Fn(HyperRequest<Incoming>, &mut HyperResponse<BoxBody<Bytes, hyper::Error>>)
+        + Send
+        + Sync
+        + 'static,
 {
    let handler = Arc::new(handler);
    let listener = StdTcpListener::bind("[::0]:0").unwrap();
-    let listener = HANDLE
-        .lock()
-        .unwrap()
-        .block_on(async move { TcpListener::from_std(listener).unwrap() });
+    listener.set_nonblocking(true).unwrap();
+    let listener = HANDLE.block_on(async move { TcpListener::from_std(listener).unwrap() });
+
    let url_string = format!("http://localhost:{}", listener.local_addr().unwrap().port());
    let url = ServoUrl::parse(&url_string).unwrap();

@ -325,27 +357,20 @@ where
    let key = load_private_key_from_file(&key_path).expect("Invalid key");

    let config = rustls::ServerConfig::builder()
-        .with_safe_defaults()
        .with_no_client_auth()
        .with_single_cert(certificates.clone(), key)
        .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))
        .expect("Could not create rustls ServerConfig");
    let acceptor = TlsAcceptor::from(Arc::new(config));

-    let mut listener = TcpListenerStream::new(listener);
    let (tx, mut rx) = tokio::sync::oneshot::channel::<()>();
    let server = async move {
        loop {
            let stream = tokio::select! {
-                stream = listener.next() => stream,
+                stream = listener.accept() => stream.unwrap().0,
                _ = &mut rx => break
            };

-            let stream = match stream {
-                Some(stream) => stream.expect("Could not accept stream: "),
-                _ => break,
-            };
-
            let stream = stream.into_std().unwrap();
            stream
                .set_read_timeout(Some(std::time::Duration::new(5, 0)))
@ -363,11 +388,12 @@ where
                },
            };

-            let _ = Http::new()
+            let _ = http1::Builder::new()
                .serve_connection(
-                    stream,
-                    service_fn(move |req: HyperRequest<Body>| {
-                        let mut response = HyperResponse::new(Body::empty());
+                    TokioIo::new(stream),
+                    service_fn(move |req: HyperRequest<Incoming>| {
+                        let mut response =
+                            HyperResponse::new(Empty::new().map_err(|_| unreachable!()).boxed());
                        handler(req, &mut response);
                        ready(Ok::<_, Infallible>(response))
                    }),
@ -376,7 +402,7 @@ where
        }
    };

-    HANDLE.lock().unwrap().spawn(server);
+    HANDLE.spawn(server);

    (
        Server {
@ -386,3 +412,9 @@ where
        url,
    )
 }
+
+pub fn make_body(bytes: Vec<u8>) -> BoxBody<Bytes, hyper::Error> {
+    Full::new(Bytes::from(bytes))
+        .map_err(|_| unreachable!())
+        .boxed()
+}