feat: Use FxHasher in places where we don't need DDoS resistance

Cargo.toml

@@ -31,10 +31,12 @@ rust-version = "1.76.0"
 [workspace.dependencies]
 # Checked against https://searchfox.org/mozilla-central/source/Cargo.lock 2024-11-11
 enum-map = { version = "2.7", default-features = false }
+indexmap = { version = "2.2", default-features = false } # See https://github.com/mozilla/neqo/issues/1858
 log = { version = "0.4", default-features = false }
 qlog = { version = "0.13", default-features = false }
 quinn-udp = { version = "0.5.6", default-features = false, features = ["direct-log", "fast-apple-datapath"] }
 regex = { version = "1.9", default-features = false, features = ["unicode-perl"] }
+rustc-hash = { version = "1.1", default-features = false, features = [ "std" ]}
 static_assertions = { version = "1.1", default-features = false }
 url = { version = "2.5.3", default-features = false, features = ["std"] }
 

neqo-bin/Cargo.toml

@@ -40,6 +40,7 @@ neqo-udp = { path = "./../neqo-udp" }
 qlog = { workspace = true }
 quinn-udp = { workspace = true }
 regex = { workspace = true }
+rustc-hash = { workspace = true }
 tokio = { version = "1", default-features = false, features = ["net", "time", "macros", "rt", "rt-multi-thread"] }
 url = { workspace = true }
 

neqo-bin/src/client/http09.rs

@@ -10,7 +10,7 @@
 
 use std::{
     cell::RefCell,
-    collections::{HashMap, VecDeque},
+    collections::VecDeque,
     fs::File,
     io::{BufWriter, Write as _},
     net::SocketAddr,
@@ -25,6 +25,7 @@ use neqo_transport::{
     CloseReason, Connection, ConnectionEvent, ConnectionIdGenerator, EmptyConnectionIdGenerator,
     Error, Output, RandomConnectionIdGenerator, State, StreamId, StreamType,
 };
+use rustc_hash::FxHashMap as HashMap;
 use url::Url;
 
 use super::{get_output_file, qlog_new, Args, CloseState, Res};
@@ -226,7 +227,7 @@ impl super::Client for Connection {
 impl<'b> Handler<'b> {
     pub fn new(url_queue: VecDeque<Url>, args: &'b Args) -> Self {
         Self {
-            streams: HashMap::new(),
+            streams: HashMap::default(),
             url_queue,
             handled_urls: Vec::new(),
             all_paths: Vec::new(),

neqo-bin/src/client/http3.rs

@@ -10,7 +10,7 @@
 
 use std::{
     cell::RefCell,
-    collections::{HashMap, VecDeque},
+    collections::VecDeque,
     fmt::Display,
     fs::File,
     io::{BufWriter, Write as _},
@@ -27,6 +27,7 @@ use neqo_transport::{
     AppError, CloseReason, Connection, EmptyConnectionIdGenerator, Error as TransportError, Output,
     RandomConnectionIdGenerator, StreamId,
 };
+use rustc_hash::FxHashMap as HashMap;
 use url::Url;
 
 use super::{get_output_file, qlog_new, Args, CloseState, Res};
@@ -45,7 +46,7 @@ impl<'a> Handler<'a> {
         let url_handler = UrlHandler {
             url_queue,
             handled_urls: Vec::new(),
-            stream_handlers: HashMap::new(),
+            stream_handlers: HashMap::default(),
             all_paths: Vec::new(),
             args,
         };

neqo-bin/src/client/mod.rs

@@ -8,7 +8,7 @@
 #![allow(clippy::unwrap_used)] // This is example code.
 
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::VecDeque,
     fmt::{self, Display},
     fs::{create_dir_all, File, OpenOptions},
     io::{self, BufWriter},
@@ -32,6 +32,7 @@ use neqo_crypto::{
 use neqo_http3::Output;
 use neqo_transport::{AppError, CloseReason, ConnectionId, Version};
 use neqo_udp::RecvBuf;
+use rustc_hash::FxHashMap as HashMap;
 use tokio::time::Sleep;
 use url::{Host, Origin, Url};
 
@@ -529,10 +530,13 @@ const fn local_addr_for(remote_addr: &SocketAddr, local_port: u16) -> SocketAddr
 
 fn urls_by_origin(urls: &[Url]) -> impl Iterator<Item = ((Host, u16), VecDeque<Url>)> {
     urls.iter()
-        .fold(HashMap::<Origin, VecDeque<Url>>::new(), |mut urls, url| {
-            urls.entry(url.origin()).or_default().push_back(url.clone());
-            urls
-        })
+        .fold(
+            HashMap::<Origin, VecDeque<Url>>::default(),
+            |mut urls, url| {
+                urls.entry(url.origin()).or_default().push_back(url.clone());
+                urls
+            },
+        )
         .into_iter()
         .filter_map(|(origin, urls)| match origin {
             Origin::Tuple(_scheme, h, p) => Some(((h, p), urls)),

neqo-bin/src/server/http09.rs

@@ -6,7 +6,7 @@
 
 #![allow(clippy::unwrap_used)] // This is example code.
 
-use std::{borrow::Cow, cell::RefCell, collections::HashMap, fmt::Display, rc::Rc, time::Instant};
+use std::{borrow::Cow, cell::RefCell, fmt::Display, rc::Rc, time::Instant};
 
 use neqo_common::{event::Provider as _, hex, qdebug, qerror, qinfo, qwarn, Datagram};
 use neqo_crypto::{generate_ech_keys, random, AllowZeroRtt, AntiReplay};
@@ -16,6 +16,7 @@ use neqo_transport::{
     ConnectionEvent, ConnectionIdGenerator, Output, State, StreamId,
 };
 use regex::Regex;
+use rustc_hash::FxHashMap as HashMap;
 
 use super::{qns_read_response, Args};
 use crate::{send_data::SendData, STREAM_IO_BUFFER_SIZE};
@@ -68,8 +69,8 @@ impl HttpServer {
         let is_qns_test = args.shared.qns_test.is_some();
         Ok(Self {
             server,
-            write_state: HashMap::new(),
-            read_state: HashMap::new(),
+            write_state: HashMap::default(),
+            read_state: HashMap::default(),
             is_qns_test,
             regex: if is_qns_test {
                 Regex::new(r"GET +/(\S+)(?:\r)?\n").map_err(|_| Error::Internal)?

neqo-bin/src/server/http3.rs

@@ -8,7 +8,6 @@
 
 use std::{
     cell::RefCell,
-    collections::HashMap,
     fmt::{self, Display},
     rc::Rc,
     time::Instant,
@@ -20,6 +19,7 @@ use neqo_http3::{
     Http3OrWebTransportStream, Http3Parameters, Http3Server, Http3ServerEvent, StreamId,
 };
 use neqo_transport::{server::ValidateAddress, ConnectionIdGenerator};
+use rustc_hash::FxHashMap as HashMap;
 
 use super::{qns_read_response, Args};
 use crate::send_data::SendData;
@@ -68,8 +68,8 @@ impl HttpServer {
         }
         Self {
             server,
-            remaining_data: HashMap::new(),
-            posts: HashMap::new(),
+            remaining_data: HashMap::default(),
+            posts: HashMap::default(),
             is_qns_test: args.shared.qns_test.is_some(),
         }
     }

neqo-http3/Cargo.toml

@@ -18,12 +18,14 @@ workspace = true
 [dependencies]
 # Checked against https://searchfox.org/mozilla-central/source/Cargo.lock 2024-11-11
 enumset = { version = "1.1", default-features = false }
+indexmap = { workspace = true }
 log = { workspace = true }
 neqo-common = { path = "./../neqo-common" }
 neqo-crypto = { path = "./../neqo-crypto" }
 neqo-qpack = { path = "./../neqo-qpack" }
 neqo-transport = { path = "./../neqo-transport" }
 qlog = { workspace = true }
+rustc-hash = { workspace = true }
 sfv = { version = "0.9", default-features = false }
 url = { workspace = true }
 

neqo-http3/src/connection.rs

@@ -4,20 +4,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::{
-    cell::RefCell,
-    collections::{BTreeSet, HashMap},
-    fmt::Debug,
-    mem,
-    rc::Rc,
-};
+use std::{cell::RefCell, fmt::Debug, mem, rc::Rc};
 
 use neqo_common::{qdebug, qerror, qinfo, qtrace, qwarn, Decoder, Header, MessageType, Role};
 use neqo_qpack::{decoder::QPackDecoder, encoder::QPackEncoder};
 use neqo_transport::{
-    streams::SendOrder, AppError, CloseReason, Connection, DatagramTracking, State, StreamId,
-    StreamType, ZeroRttState,
+    streams::SendOrder, AppError, CloseReason, Connection, DatagramTracking, IndexMap, State,
+    StreamId, StreamType, ZeroRttState,
 };
+use rustc_hash::FxHashSet as HashSet;
 
 use crate::{
     client_events::Http3ClientEvents,
@@ -303,9 +298,9 @@ pub struct Http3Connection {
     pub qpack_encoder: Rc<RefCell<QPackEncoder>>,
     pub qpack_decoder: Rc<RefCell<QPackDecoder>>,
     settings_state: Http3RemoteSettingsState,
-    streams_with_pending_data: BTreeSet<StreamId>,
-    pub send_streams: HashMap<StreamId, Box<dyn SendStream>>,
-    pub recv_streams: HashMap<StreamId, Box<dyn RecvStream>>,
+    streams_with_pending_data: HashSet<StreamId>,
+    pub send_streams: IndexMap<StreamId, Box<dyn SendStream>>,
+    pub recv_streams: IndexMap<StreamId, Box<dyn RecvStream>>,
     webtransport: ExtendedConnectFeature,
 }
 
@@ -334,9 +329,9 @@ impl Http3Connection {
             ),
             local_params: conn_params,
             settings_state: Http3RemoteSettingsState::NotReceived,
-            streams_with_pending_data: BTreeSet::new(),
-            send_streams: HashMap::new(),
-            recv_streams: HashMap::new(),
+            streams_with_pending_data: HashSet::default(),
+            send_streams: IndexMap::default(),
+            recv_streams: IndexMap::default(),
             role,
         }
     }
@@ -1182,10 +1177,10 @@ impl Http3Connection {
                             events,
                             self.role,
                             self.recv_streams
-                                .remove(&stream_id)
+                                .shift_remove(&stream_id)
                                 .ok_or(Error::Internal)?,
                             self.send_streams
-                                .remove(&stream_id)
+                                .shift_remove(&stream_id)
                                 .ok_or(Error::Internal)?,
                         )?));
                     self.add_streams(
@@ -1541,14 +1536,14 @@ impl Http3Connection {
             qtrace!("Remove the extended connect sub receiver stream {id}");
             // Use CloseType::ResetRemote so that an event will be sent. CloseType::LocalError would
             // have the same effect.
-            if let Some(mut s) = self.recv_streams.remove(&id) {
+            if let Some(mut s) = self.recv_streams.shift_remove(&id) {
                 drop(s.reset(CloseType::ResetRemote(Error::HttpRequestCancelled.code())));
             }
             drop(conn.stream_stop_sending(id, Error::HttpRequestCancelled.code()));
         }
         for id in send {
             qtrace!("Remove the extended connect sub send stream {id}");
-            if let Some(mut s) = self.send_streams.remove(&id) {
+            if let Some(mut s) = self.send_streams.shift_remove(&id) {
                 s.handle_stop_sending(CloseType::ResetRemote(Error::HttpRequestCancelled.code()));
             }
             drop(conn.stream_reset_send(id, Error::HttpRequestCancelled.code()));
@@ -1560,10 +1555,10 @@ impl Http3Connection {
         stream_id: StreamId,
         conn: &mut Connection,
     ) -> Option<Box<dyn RecvStream>> {
-        let stream = self.recv_streams.remove(&stream_id);
+        let stream = self.recv_streams.shift_remove(&stream_id);
         if let Some(s) = &stream {
             if s.stream_type() == Http3StreamType::ExtendedConnect {
-                self.send_streams.remove(&stream_id)?;
+                self.send_streams.shift_remove(&stream_id)?;
                 if let Some(wt) = s.webtransport() {
                     self.remove_extended_connect(&wt, conn);
                 }
@@ -1577,10 +1572,10 @@ impl Http3Connection {
         stream_id: StreamId,
         conn: &mut Connection,
     ) -> Option<Box<dyn SendStream>> {
-        let stream = self.send_streams.remove(&stream_id);
+        let stream = self.send_streams.shift_remove(&stream_id);
         if let Some(s) = &stream {
             if s.stream_type() == Http3StreamType::ExtendedConnect {
-                if let Some(wt) = self.recv_streams.remove(&stream_id)?.webtransport() {
+                if let Some(wt) = self.recv_streams.shift_remove(&stream_id)?.webtransport() {
                     self.remove_extended_connect(&wt, conn);
                 }
             }

neqo-http3/src/control_stream_local.rs

@@ -4,10 +4,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::collections::{HashMap, VecDeque};
+use std::collections::VecDeque;
 
 use neqo_common::{qtrace, Encoder};
-use neqo_transport::{Connection, StreamId, StreamType};
+use neqo_transport::{Connection, IndexMap, StreamId, StreamType};
 
 use crate::{frames::HFrame, BufferedStream, Error, Http3StreamType, RecvStream, Res};
 
@@ -50,7 +50,7 @@ impl ControlStreamLocal {
     pub fn send(
         &mut self,
         conn: &mut Connection,
-        recv_conn: &mut HashMap<StreamId, Box<dyn RecvStream>>,
+        recv_conn: &mut IndexMap<StreamId, Box<dyn RecvStream>>,
     ) -> Res<()> {
         self.stream.send_buffer(conn)?;
         self.send_priority_update(conn, recv_conn)
@@ -59,7 +59,7 @@ impl ControlStreamLocal {
     fn send_priority_update(
         &mut self,
         conn: &mut Connection,
-        recv_conn: &mut HashMap<StreamId, Box<dyn RecvStream>>,
+        recv_conn: &mut IndexMap<StreamId, Box<dyn RecvStream>>,
     ) -> Res<()> {
         // send all necessary priority updates
         while let Some(update_id) = self.outstanding_priority_update.pop_front() {