feat(http1): decouple preserving header case from FFI (fixes hyperium#2313)

The feature is now supported in both the server and the client
and can be combined with the title case feature, for headers
which don't have entries in the header case map.

Author: nox

src/client/client.rs

@@ -972,6 +972,17 @@ impl Builder {
         self
     }
 
+    /// Set whether HTTP/1 connections will write header names as provided
+    /// at the socket level.
+    ///
+    /// Note that this setting does not affect HTTP/2.
+    ///
+    /// Default is false.
+    pub fn http1_preserve_header_case(&mut self, val: bool) -> &mut Self {
+        self.conn_builder.h1_preserve_header_case(val);
+        self
+    }
+
     /// Set whether HTTP/0.9 responses should be tolerated.
     ///
     /// Default is false.

src/client/conn.rs

@@ -124,6 +124,7 @@ pub struct Builder {
     pub(super) exec: Exec,
     h09_responses: bool,
     h1_title_case_headers: bool,
+    h1_preserve_header_case: bool,
     h1_read_buf_exact_size: Option<usize>,
     h1_max_buf_size: Option<usize>,
     #[cfg(feature = "http2")]
@@ -497,6 +498,7 @@ impl Builder {
             h09_responses: false,
             h1_read_buf_exact_size: None,
             h1_title_case_headers: false,
+            h1_preserve_header_case: false,
             h1_max_buf_size: None,
             #[cfg(feature = "http2")]
             h2_builder: Default::default(),
@@ -526,6 +528,11 @@ impl Builder {
         self
     }
 
+    pub(crate) fn h1_preserve_header_case(&mut self, enabled: bool) -> &mut Builder {
+        self.h1_preserve_header_case = enabled;
+        self
+    }
+
     pub(super) fn h1_read_buf_exact_size(&mut self, sz: Option<usize>) -> &mut Builder {
         self.h1_read_buf_exact_size = sz;
         self.h1_max_buf_size = None;
@@ -707,6 +714,9 @@ impl Builder {
                     if opts.h1_title_case_headers {
                         conn.set_title_case_headers();
                     }
+                    if opts.h1_preserve_header_case {
+                        conn.set_preserve_header_case();
+                    }
                     if opts.h09_responses {
                         conn.set_h09_responses();
                     }

src/ext.rs

@@ -0,0 +1,64 @@
+//! HTTP extensions
+
+use bytes::Bytes;
+#[cfg(feature = "http1")]
+use http::header::{HeaderName, IntoHeaderName, ValueIter};
+use http::HeaderMap;
+
+/// A map from header names to their original casing as received in an HTTP message.
+///
+/// If an HTTP/1 response `res` is parsed on a connection whose option
+/// [`http1_preserve_header_case`] was set to true and the response included
+/// the following headers:
+///
+/// ```ignore
+/// x-Bread: Baguette
+/// X-BREAD: Pain
+/// x-bread: Ficelle
+/// ```
+///
+/// Then `res.extensions().get::<HeaderCaseMap>()` will return a map with:
+///
+/// ```ignore
+/// HeaderCaseMap({
+///     "x-bread": ["x-Bread", "X-BREAD", "x-bread"],
+/// })
+/// ```
+///
+/// [`http1_preserve_header_case`]: /client/struct.Client.html#method.http1_preserve_header_case
+#[derive(Clone, Debug)]
+pub struct HeaderCaseMap(HeaderMap<Bytes>);
+
+#[cfg(feature = "http1")]
+impl HeaderCaseMap {
+    /// Returns a view of all spellings associated with that header name,
+    /// in the order they were found.
+    pub fn get_all<'a>(
+        &'a self,
+        name: &HeaderName,
+    ) -> impl Iterator<Item = impl AsRef<[u8]> + 'a> + 'a {
+        self.get_all_internal(name).into_iter()
+    }
+
+    /// Returns a view of all spellings associated with that header name,
+    /// in the order they were found.
+    pub(crate) fn get_all_internal<'a>(&'a self, name: &HeaderName) -> ValueIter<'_, Bytes> {
+        self.0.get_all(name).into_iter()
+    }
+
+    pub(crate) fn default() -> Self {
+        Self(Default::default())
+    }
+
+    #[cfg(any(test, feature = "ffi"))]
+    pub(crate) fn insert(&mut self, name: HeaderName, orig: Bytes) {
+        self.0.insert(name, orig);
+    }
+
+    pub(crate) fn append<N>(&mut self, name: N, orig: Bytes)
+    where
+        N: IntoHeaderName,
+    {
+        self.0.append(name, orig);
+    }
+}

src/ffi/client.rs

@@ -106,8 +106,11 @@ unsafe impl AsTaskType for hyper_clientconn {
 ffi_fn! {
     /// Creates a new set of HTTP clientconn options to be used in a handshake.
     fn hyper_clientconn_options_new() -> *mut hyper_clientconn_options {
+        let mut builder = conn::Builder::new();
+        builder.h1_preserve_header_case(true);
+
         Box::into_raw(Box::new(hyper_clientconn_options {
-            builder: conn::Builder::new(),
+            builder,
             exec: WeakExec::new(),
         }))
     } ?= std::ptr::null_mut()

src/ffi/http_types.rs

@@ -6,6 +6,7 @@ use super::body::hyper_body;
 use super::error::hyper_code;
 use super::task::{hyper_task_return_type, AsTaskType};
 use super::HYPER_ITER_CONTINUE;
+use crate::ext::HeaderCaseMap;
 use crate::header::{HeaderName, HeaderValue};
 use crate::{Body, HeaderMap, Method, Request, Response, Uri};
 
@@ -18,16 +19,11 @@ pub struct hyper_response(pub(super) Response<Body>);
 /// An HTTP header map.
 ///
 /// These can be part of a request or response.
-#[derive(Default)]
 pub struct hyper_headers {
     pub(super) headers: HeaderMap,
     orig_casing: HeaderCaseMap,
 }
 
-// Will probably be moved to `hyper::ext::http1`
-#[derive(Debug, Default)]
-pub(crate) struct HeaderCaseMap(HeaderMap<Bytes>);
-
 #[derive(Debug)]
 pub(crate) struct ReasonPhrase(pub(crate) Bytes);
 
@@ -229,7 +225,7 @@ impl hyper_response {
         let orig_casing = resp
             .extensions_mut()
             .remove::<HeaderCaseMap>()
-            .unwrap_or_default();
+            .unwrap_or_else(HeaderCaseMap::default);
         resp.extensions_mut().insert(hyper_headers {
             headers,
             orig_casing,
@@ -265,10 +261,7 @@ type hyper_headers_foreach_callback =
 impl hyper_headers {
     pub(super) fn get_or_default(ext: &mut http::Extensions) -> &mut hyper_headers {
         if let None = ext.get_mut::<hyper_headers>() {
-            ext.insert(hyper_headers {
-                headers: Default::default(),
-                orig_casing: Default::default(),
-            });
+            ext.insert(hyper_headers::default());
         }
 
         ext.get_mut::<hyper_headers>().unwrap()
@@ -290,11 +283,11 @@ ffi_fn! {
         //
         // TODO: consider adding http::HeaderMap::entries() iterator
         for name in headers.headers.keys() {
-            let mut names = headers.orig_casing.get_all(name).iter();
+            let mut names = headers.orig_casing.get_all(name);
 
             for value in headers.headers.get_all(name) {
                 let (name_ptr, name_len) = if let Some(orig_name) = names.next() {
-                    (orig_name.as_ptr(), orig_name.len())
+                    (orig_name.as_bytes().as_ptr(), orig_name.as_bytes().len())
                 } else {
                     (
                         name.as_str().as_bytes().as_ptr(),
@@ -349,6 +342,15 @@ ffi_fn! {
     }
 }
 
+impl Default for hyper_headers {
+    fn default() -> Self {
+        Self {
+            headers: Default::default(),
+            orig_casing: HeaderCaseMap::default(),
+        }
+    }
+}
+
 unsafe fn raw_name_value(
     name: *const u8,
     name_len: size_t,
@@ -370,25 +372,6 @@ unsafe fn raw_name_value(
     Ok((name, value, orig_name))
 }
 
-// ===== impl HeaderCaseMap =====
-
-impl HeaderCaseMap {
-    pub(crate) fn get_all(&self, name: &HeaderName) -> http::header::GetAll<'_, Bytes> {
-        self.0.get_all(name)
-    }
-
-    pub(crate) fn insert(&mut self, name: HeaderName, orig: Bytes) {
-        self.0.insert(name, orig);
-    }
-
-    pub(crate) fn append<N>(&mut self, name: N, orig: Bytes)
-    where
-        N: http::header::IntoHeaderName,
-    {
-        self.0.append(name, orig);
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/lib.rs

@@ -80,6 +80,7 @@ mod cfg;
 mod common;
 pub mod body;
 mod error;
+pub mod ext;
 #[cfg(test)]
 mod mock;
 #[cfg(any(feature = "http1", feature = "http2",))]

src/proto/h1/conn.rs

@@ -44,7 +44,6 @@ where
                 error: None,
                 keep_alive: KA::Busy,
                 method: None,
-                #[cfg(feature = "ffi")]
                 preserve_header_case: false,
                 title_case_headers: false,
                 h09_responses: false,
@@ -74,11 +73,15 @@ where
         self.io.set_read_buf_exact_size(sz);
     }
 
-    #[cfg(feature = "client")]
     pub(crate) fn set_title_case_headers(&mut self) {
         self.state.title_case_headers = true;
     }
 
+    #[cfg(feature = "client")]
+    pub(crate) fn set_preserve_header_case(&mut self) {
+        self.state.preserve_header_case = true;
+    }
+
     #[cfg(feature = "client")]
     pub(crate) fn set_h09_responses(&mut self) {
         self.state.h09_responses = true;
@@ -150,7 +153,6 @@ where
             ParseContext {
                 cached_headers: &mut self.state.cached_headers,
                 req_method: &mut self.state.method,
-                #[cfg(feature = "ffi")]
                 preserve_header_case: self.state.preserve_header_case,
                 h09_responses: self.state.h09_responses,
             }
@@ -488,16 +490,6 @@ where
 
         self.enforce_version(&mut head);
 
-        // Maybe check if we should preserve header casing on received
-        // message headers...
-        #[cfg(feature = "ffi")]
-        {
-            if T::is_client() && !self.state.preserve_header_case {
-                self.state.preserve_header_case =
-                    head.extensions.get::<crate::ffi::HeaderCaseMap>().is_some();
-            }
-        }
-
         let buf = self.io.headers_buf();
         match super::role::encode_headers::<T>(
             Encode {
@@ -760,7 +752,6 @@ struct State {
     /// This is used to know things such as if the message can include
     /// a body or not.
     method: Option<Method>,
-    #[cfg(feature = "ffi")]
     preserve_header_case: bool,
     title_case_headers: bool,
     h09_responses: bool,

src/proto/h1/io.rs

@@ -159,7 +159,6 @@ where
                 ParseContext {
                     cached_headers: parse_ctx.cached_headers,
                     req_method: parse_ctx.req_method,
-                    #[cfg(feature = "ffi")]
                     preserve_header_case: parse_ctx.preserve_header_case,
                     h09_responses: parse_ctx.h09_responses,
                 },
@@ -639,7 +638,6 @@ mod tests {
             let parse_ctx = ParseContext {
                 cached_headers: &mut None,
                 req_method: &mut None,
-                #[cfg(feature = "ffi")]
                 preserve_header_case: false,
                 h09_responses: false,
             };

src/proto/h1/mod.rs

@@ -70,7 +70,6 @@ pub(crate) struct ParsedMessage<T> {
 pub(crate) struct ParseContext<'a> {
     cached_headers: &'a mut Option<HeaderMap>,
     req_method: &'a mut Option<Method>,
-    #[cfg(feature = "ffi")]
     preserve_header_case: bool,
     h09_responses: bool,
 }