Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 6333 insertions, 0 deletions

diff --git a/third_party/rust/http/src/header/map.rs b/third_party/rust/http/src/header/map.rs
new file mode 100644
index 0000000000..13cbc3a3f9
--- /dev/null
+++ b/third_party/rust/http/src/header/map.rs
@@ -0,0 +1,3496 @@
+use std::collections::HashMap;
+use std::collections::hash_map::RandomState;
+use std::convert::TryFrom;
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::{FromIterator, FusedIterator};
+use std::marker::PhantomData;
+use std::{fmt, mem, ops, ptr, vec};
+
+use crate::Error;
+
+use super::HeaderValue;
+use super::name::{HdrName, HeaderName, InvalidHeaderName};
+
+pub use self::as_header_name::AsHeaderName;
+pub use self::into_header_name::IntoHeaderName;
+
+/// A set of HTTP headers
+///
+/// `HeaderMap` is an multimap of [`HeaderName`] to values.
+///
+/// [`HeaderName`]: struct.HeaderName.html
+///
+/// # Examples
+///
+/// Basic usage
+///
+/// ```
+/// # use http::HeaderMap;
+/// # use http::header::{CONTENT_LENGTH, HOST, LOCATION};
+/// let mut headers = HeaderMap::new();
+///
+/// headers.insert(HOST, "example.com".parse().unwrap());
+/// headers.insert(CONTENT_LENGTH, "123".parse().unwrap());
+///
+/// assert!(headers.contains_key(HOST));
+/// assert!(!headers.contains_key(LOCATION));
+///
+/// assert_eq!(headers[HOST], "example.com");
+///
+/// headers.remove(HOST);
+///
+/// assert!(!headers.contains_key(HOST));
+/// ```
+#[derive(Clone)]
+pub struct HeaderMap<T = HeaderValue> {
+    // Used to mask values to get an index
+    mask: Size,
+    indices: Box<[Pos]>,
+    entries: Vec<Bucket<T>>,
+    extra_values: Vec<ExtraValue<T>>,
+    danger: Danger,
+}
+
+// # Implementation notes
+//
+// Below, you will find a fairly large amount of code. Most of this is to
+// provide the necessary functions to efficiently manipulate the header
+// multimap. The core hashing table is based on robin hood hashing [1]. While
+// this is the same hashing algorithm used as part of Rust's `HashMap` in
+// stdlib, many implementation details are different. The two primary reasons
+// for this divergence are that `HeaderMap` is a multimap and the structure has
+// been optimized to take advantage of the characteristics of HTTP headers.
+//
+// ## Structure Layout
+//
+// Most of the data contained by `HeaderMap` is *not* stored in the hash table.
+// Instead, pairs of header name and *first* associated header value are stored
+// in the `entries` vector. If the header name has more than one associated
+// header value, then additional values are stored in `extra_values`. The actual
+// hash table (`indices`) only maps hash codes to indices in `entries`. This
+// means that, when an eviction happens, the actual header name and value stay
+// put and only a tiny amount of memory has to be copied.
+//
+// Extra values associated with a header name are tracked using a linked list.
+// Links are formed with offsets into `extra_values` and not pointers.
+//
+// [1]: https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing
+
+/// `HeaderMap` entry iterator.
+///
+/// Yields `(&HeaderName, &value)` tuples. The same header name may be yielded
+/// more than once if it has more than one associated value.
+#[derive(Debug)]
+pub struct Iter<'a, T> {
+    inner: IterMut<'a, T>,
+}
+
+/// `HeaderMap` mutable entry iterator
+///
+/// Yields `(&HeaderName, &mut value)` tuples. The same header name may be
+/// yielded more than once if it has more than one associated value.
+#[derive(Debug)]
+pub struct IterMut<'a, T> {
+    map: *mut HeaderMap<T>,
+    entry: usize,
+    cursor: Option<Cursor>,
+    lt: PhantomData<&'a mut HeaderMap<T>>,
+}
+
+/// An owning iterator over the entries of a `HeaderMap`.
+///
+/// This struct is created by the `into_iter` method on `HeaderMap`.
+#[derive(Debug)]
+pub struct IntoIter<T> {
+    // If None, pull from `entries`
+    next: Option<usize>,
+    entries: vec::IntoIter<Bucket<T>>,
+    extra_values: Vec<ExtraValue<T>>,
+}
+
+/// An iterator over `HeaderMap` keys.
+///
+/// Each header name is yielded only once, even if it has more than one
+/// associated value.
+#[derive(Debug)]
+pub struct Keys<'a, T> {
+    inner: ::std::slice::Iter<'a, Bucket<T>>,
+}
+
+/// `HeaderMap` value iterator.
+///
+/// Each value contained in the `HeaderMap` will be yielded.
+#[derive(Debug)]
+pub struct Values<'a, T> {
+    inner: Iter<'a, T>,
+}
+
+/// `HeaderMap` mutable value iterator
+#[derive(Debug)]
+pub struct ValuesMut<'a, T> {
+    inner: IterMut<'a, T>,
+}
+
+/// A drain iterator for `HeaderMap`.
+#[derive(Debug)]
+pub struct Drain<'a, T> {
+    idx: usize,
+    len: usize,
+    entries: *mut [Bucket<T>],
+    // If None, pull from `entries`
+    next: Option<usize>,
+    extra_values: *mut Vec<ExtraValue<T>>,
+    lt: PhantomData<&'a mut HeaderMap<T>>,
+}
+
+/// A view to all values stored in a single entry.
+///
+/// This struct is returned by `HeaderMap::get_all`.
+#[derive(Debug)]
+pub struct GetAll<'a, T> {
+    map: &'a HeaderMap<T>,
+    index: Option<usize>,
+}
+
+/// A view into a single location in a `HeaderMap`, which may be vacant or occupied.
+#[derive(Debug)]
+pub enum Entry<'a, T: 'a> {
+    /// An occupied entry
+    Occupied(OccupiedEntry<'a, T>),
+
+    /// A vacant entry
+    Vacant(VacantEntry<'a, T>),
+}
+
+/// A view into a single empty location in a `HeaderMap`.
+///
+/// This struct is returned as part of the `Entry` enum.
+#[derive(Debug)]
+pub struct VacantEntry<'a, T> {
+    map: &'a mut HeaderMap<T>,
+    key: HeaderName,
+    hash: HashValue,
+    probe: usize,
+    danger: bool,
+}
+
+/// A view into a single occupied location in a `HeaderMap`.
+///
+/// This struct is returned as part of the `Entry` enum.
+#[derive(Debug)]
+pub struct OccupiedEntry<'a, T> {
+    map: &'a mut HeaderMap<T>,
+    probe: usize,
+    index: usize,
+}
+
+/// An iterator of all values associated with a single header name.
+#[derive(Debug)]
+pub struct ValueIter<'a, T> {
+    map: &'a HeaderMap<T>,
+    index: usize,
+    front: Option<Cursor>,
+    back: Option<Cursor>,
+}
+
+/// A mutable iterator of all values associated with a single header name.
+#[derive(Debug)]
+pub struct ValueIterMut<'a, T> {
+    map: *mut HeaderMap<T>,
+    index: usize,
+    front: Option<Cursor>,
+    back: Option<Cursor>,
+    lt: PhantomData<&'a mut HeaderMap<T>>,
+}
+
+/// An drain iterator of all values associated with a single header name.
+#[derive(Debug)]
+pub struct ValueDrain<'a, T> {
+    first: Option<T>,
+    next: Option<::std::vec::IntoIter<T>>,
+    lt: PhantomData<&'a mut HeaderMap<T>>,
+}
+
+/// Tracks the value iterator state
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+enum Cursor {
+    Head,
+    Values(usize),
+}
+
+/// Type used for representing the size of a HeaderMap value.
+///
+/// 32,768 is more than enough entries for a single header map. Setting this
+/// limit enables using `u16` to represent all offsets, which takes 2 bytes
+/// instead of 8 on 64 bit processors.
+///
+/// Setting this limit is especially benificial for `indices`, making it more
+/// cache friendly. More hash codes can fit in a cache line.
+///
+/// You may notice that `u16` may represent more than 32,768 values. This is
+/// true, but 32,768 should be plenty and it allows us to reserve the top bit
+/// for future usage.
+type Size = u16;
+
+/// This limit falls out from above.
+const MAX_SIZE: usize = 1 << 15;
+
+/// An entry in the hash table. This represents the full hash code for an entry
+/// as well as the position of the entry in the `entries` vector.
+#[derive(Copy, Clone)]
+struct Pos {
+    // Index in the `entries` vec
+    index: Size,
+    // Full hash value for the entry.
+    hash: HashValue,
+}
+
+/// Hash values are limited to u16 as well. While `fast_hash` and `Hasher`
+/// return `usize` hash codes, limiting the effective hash code to the lower 16
+/// bits is fine since we know that the `indices` vector will never grow beyond
+/// that size.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+struct HashValue(u16);
+
+/// Stores the data associated with a `HeaderMap` entry. Only the first value is
+/// included in this struct. If a header name has more than one associated
+/// value, all extra values are stored in the `extra_values` vector. A doubly
+/// linked list of entries is maintained. The doubly linked list is used so that
+/// removing a value is constant time. This also has the nice property of
+/// enabling double ended iteration.
+#[derive(Debug, Clone)]
+struct Bucket<T> {
+    hash: HashValue,
+    key: HeaderName,
+    value: T,
+    links: Option<Links>,
+}
+
+/// The head and tail of the value linked list.
+#[derive(Debug, Copy, Clone)]
+struct Links {
+    next: usize,
+    tail: usize,
+}
+
+/// Access to the `links` value in a slice of buckets.
+///
+/// It's important that no other field is accessed, since it may have been
+/// freed in a `Drain` iterator.
+#[derive(Debug)]
+struct RawLinks<T>(*mut [Bucket<T>]);
+
+/// Node in doubly-linked list of header value entries
+#[derive(Debug, Clone)]
+struct ExtraValue<T> {
+    value: T,
+    prev: Link,
+    next: Link,
+}
+
+/// A header value node is either linked to another node in the `extra_values`
+/// list or it points to an entry in `entries`. The entry in `entries` is the
+/// start of the list and holds the associated header name.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+enum Link {
+    Entry(usize),
+    Extra(usize),
+}
+
+/// Tracks the header map danger level! This relates to the adaptive hashing
+/// algorithm. A HeaderMap starts in the "green" state, when a large number of
+/// collisions are detected, it transitions to the yellow state. At this point,
+/// the header map will either grow and switch back to the green state OR it
+/// will transition to the red state.
+///
+/// When in the red state, a safe hashing algorithm is used and all values in
+/// the header map have to be rehashed.
+#[derive(Clone)]
+enum Danger {
+    Green,
+    Yellow,
+    Red(RandomState),
+}
+
+// Constants related to detecting DOS attacks.
+//
+// Displacement is the number of entries that get shifted when inserting a new
+// value. Forward shift is how far the entry gets stored from the ideal
+// position.
+//
+// The current constant values were picked from another implementation. It could
+// be that there are different values better suited to the header map case.
+const DISPLACEMENT_THRESHOLD: usize = 128;
+const FORWARD_SHIFT_THRESHOLD: usize = 512;
+
+// The default strategy for handling the yellow danger state is to increase the
+// header map capacity in order to (hopefully) reduce the number of collisions.
+// If growing the hash map would cause the load factor to drop bellow this
+// threshold, then instead of growing, the headermap is switched to the red
+// danger state and safe hashing is used instead.
+const LOAD_FACTOR_THRESHOLD: f32 = 0.2;
+
+// Macro used to iterate the hash table starting at a given point, looping when
+// the end is hit.
+macro_rules! probe_loop {
+    ($label:tt: $probe_var: ident < $len: expr, $body: expr) => {
+        debug_assert!($len > 0);
+        $label:
+        loop {
+            if $probe_var < $len {
+                $body
+                $probe_var += 1;
+            } else {
+                $probe_var = 0;
+            }
+        }
+    };
+    ($probe_var: ident < $len: expr, $body: expr) => {
+        debug_assert!($len > 0);
+        loop {
+            if $probe_var < $len {
+                $body
+                $probe_var += 1;
+            } else {
+                $probe_var = 0;
+            }
+        }
+    };
+}
+
+// First part of the robinhood algorithm. Given a key, find the slot in which it
+// will be inserted. This is done by starting at the "ideal" spot. Then scanning
+// until the destination slot is found. A destination slot is either the next
+// empty slot or the next slot that is occupied by an entry that has a lower
+// displacement (displacement is the distance from the ideal spot).
+//
+// This is implemented as a macro instead of a function that takes a closure in
+// order to guarantee that it is "inlined". There is no way to annotate closures
+// to guarantee inlining.
+macro_rules! insert_phase_one {
+    ($map:ident,
+     $key:expr,
+     $probe:ident,
+     $pos:ident,
+     $hash:ident,
+     $danger:ident,
+     $vacant:expr,
+     $occupied:expr,
+     $robinhood:expr) =>
+    {{
+        let $hash = hash_elem_using(&$map.danger, &$key);
+        let mut $probe = desired_pos($map.mask, $hash);
+        let mut dist = 0;
+        let ret;
+
+        // Start at the ideal position, checking all slots
+        probe_loop!('probe: $probe < $map.indices.len(), {
+            if let Some(($pos, entry_hash)) = $map.indices[$probe].resolve() {
+                // The slot is already occupied, but check if it has a lower
+                // displacement.
+                let their_dist = probe_distance($map.mask, entry_hash, $probe);
+
+                if their_dist < dist {
+                    // The new key's distance is larger, so claim this spot and
+                    // displace the current entry.
+                    //
+                    // Check if this insertion is above the danger threshold.
+                    let $danger =
+                        dist >= FORWARD_SHIFT_THRESHOLD && !$map.danger.is_red();
+
+                    ret = $robinhood;
+                    break 'probe;
+                } else if entry_hash == $hash && $map.entries[$pos].key == $key {
+                    // There already is an entry with the same key.
+                    ret = $occupied;
+                    break 'probe;
+                }
+            } else {
+                // The entry is vacant, use it for this key.
+                let $danger =
+                    dist >= FORWARD_SHIFT_THRESHOLD && !$map.danger.is_red();
+
+                ret = $vacant;
+                break 'probe;
+            }
+
+            dist += 1;
+        });
+
+        ret
+    }}
+}
+
+// ===== impl HeaderMap =====
+
+impl HeaderMap {
+    /// Create an empty `HeaderMap`.
+    ///
+    /// The map will be created without any capacity. This function will not
+    /// allocate.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let map = HeaderMap::new();
+    ///
+    /// assert!(map.is_empty());
+    /// assert_eq!(0, map.capacity());
+    /// ```
+    pub fn new() -> Self {
+        HeaderMap::with_capacity(0)
+    }
+}
+
+impl<T> HeaderMap<T> {
+    /// Create an empty `HeaderMap` with the specified capacity.
+    ///
+    /// The returned map will allocate internal storage in order to hold about
+    /// `capacity` elements without reallocating. However, this is a "best
+    /// effort" as there are usage patterns that could cause additional
+    /// allocations before `capacity` headers are stored in the map.
+    ///
+    /// More capacity than requested may be allocated.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let map: HeaderMap<u32> = HeaderMap::with_capacity(10);
+    ///
+    /// assert!(map.is_empty());
+    /// assert_eq!(12, map.capacity());
+    /// ```
+    pub fn with_capacity(capacity: usize) -> HeaderMap<T> {
+        if capacity == 0 {
+            HeaderMap {
+                mask: 0,
+                indices: Box::new([]), // as a ZST, this doesn't actually allocate anything
+                entries: Vec::new(),
+                extra_values: Vec::new(),
+                danger: Danger::Green,
+            }
+        } else {
+            let raw_cap = to_raw_capacity(capacity).next_power_of_two();
+            assert!(raw_cap <= MAX_SIZE, "requested capacity too large");
+            debug_assert!(raw_cap > 0);
+
+            HeaderMap {
+                mask: (raw_cap - 1) as Size,
+                indices: vec![Pos::none(); raw_cap].into_boxed_slice(),
+                entries: Vec::with_capacity(raw_cap),
+                extra_values: Vec::new(),
+                danger: Danger::Green,
+            }
+        }
+    }
+
+    /// Returns the number of headers stored in the map.
+    ///
+    /// This number represents the total number of **values** stored in the map.
+    /// This number can be greater than or equal to the number of **keys**
+    /// stored given that a single key may have more than one associated value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{ACCEPT, HOST};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// assert_eq!(0, map.len());
+    ///
+    /// map.insert(ACCEPT, "text/plain".parse().unwrap());
+    /// map.insert(HOST, "localhost".parse().unwrap());
+    ///
+    /// assert_eq!(2, map.len());
+    ///
+    /// map.append(ACCEPT, "text/html".parse().unwrap());
+    ///
+    /// assert_eq!(3, map.len());
+    /// ```
+    pub fn len(&self) -> usize {
+        self.entries.len() + self.extra_values.len()
+    }
+
+    /// Returns the number of keys stored in the map.
+    ///
+    /// This number will be less than or equal to `len()` as each key may have
+    /// more than one associated value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{ACCEPT, HOST};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// assert_eq!(0, map.keys_len());
+    ///
+    /// map.insert(ACCEPT, "text/plain".parse().unwrap());
+    /// map.insert(HOST, "localhost".parse().unwrap());
+    ///
+    /// assert_eq!(2, map.keys_len());
+    ///
+    /// map.insert(ACCEPT, "text/html".parse().unwrap());
+    ///
+    /// assert_eq!(2, map.keys_len());
+    /// ```
+    pub fn keys_len(&self) -> usize {
+        self.entries.len()
+    }
+
+    /// Returns true if the map contains no elements.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// assert!(map.is_empty());
+    ///
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    ///
+    /// assert!(!map.is_empty());
+    /// ```
+    pub fn is_empty(&self) -> bool {
+        self.entries.len() == 0
+    }
+
+    /// Clears the map, removing all key-value pairs. Keeps the allocated memory
+    /// for reuse.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    ///
+    /// map.clear();
+    /// assert!(map.is_empty());
+    /// assert!(map.capacity() > 0);
+    /// ```
+    pub fn clear(&mut self) {
+        self.entries.clear();
+        self.extra_values.clear();
+        self.danger = Danger::Green;
+
+        for e in self.indices.iter_mut() {
+            *e = Pos::none();
+        }
+    }
+
+    /// Returns the number of headers the map can hold without reallocating.
+    ///
+    /// This number is an approximation as certain usage patterns could cause
+    /// additional allocations before the returned capacity is filled.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// assert_eq!(0, map.capacity());
+    ///
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    /// assert_eq!(6, map.capacity());
+    /// ```
+    pub fn capacity(&self) -> usize {
+        usable_capacity(self.indices.len())
+    }
+
+    /// Reserves capacity for at least `additional` more headers to be inserted
+    /// into the `HeaderMap`.
+    ///
+    /// The header map may reserve more space to avoid frequent reallocations.
+    /// Like with `with_capacity`, this will be a "best effort" to avoid
+    /// allocations until `additional` more headers are inserted. Certain usage
+    /// patterns could cause additional allocations before the number is
+    /// reached.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new allocation size overflows `usize`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// map.reserve(10);
+    /// # map.insert(HOST, "bar".parse().unwrap());
+    /// ```
+    pub fn reserve(&mut self, additional: usize) {
+        // TODO: This can't overflow if done properly... since the max # of
+        // elements is u16::MAX.
+        let cap = self
+            .entries
+            .len()
+            .checked_add(additional)
+            .expect("reserve overflow");
+
+        if cap > self.indices.len() {
+            let cap = cap.next_power_of_two();
+            assert!(cap <= MAX_SIZE, "header map reserve over max capacity");
+            assert!(cap != 0, "header map reserve overflowed");
+
+            if self.entries.len() == 0 {
+                self.mask = cap as Size - 1;
+                self.indices = vec![Pos::none(); cap].into_boxed_slice();
+                self.entries = Vec::with_capacity(usable_capacity(cap));
+            } else {
+                self.grow(cap);
+            }
+        }
+    }
+
+    /// Returns a reference to the value associated with the key.
+    ///
+    /// If there are multiple values associated with the key, then the first one
+    /// is returned. Use `get_all` to get all values associated with a given
+    /// key. Returns `None` if there are no values associated with the key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// assert!(map.get("host").is_none());
+    ///
+    /// map.insert(HOST, "hello".parse().unwrap());
+    /// assert_eq!(map.get(HOST).unwrap(), &"hello");
+    /// assert_eq!(map.get("host").unwrap(), &"hello");
+    ///
+    /// map.append(HOST, "world".parse().unwrap());
+    /// assert_eq!(map.get("host").unwrap(), &"hello");
+    /// ```
+    pub fn get<K>(&self, key: K) -> Option<&T>
+    where
+        K: AsHeaderName,
+    {
+        self.get2(&key)
+    }
+
+    fn get2<K>(&self, key: &K) -> Option<&T>
+    where
+        K: AsHeaderName,
+    {
+        match key.find(self) {
+            Some((_, found)) => {
+                let entry = &self.entries[found];
+                Some(&entry.value)
+            }
+            None => None,
+        }
+    }
+
+    /// Returns a mutable reference to the value associated with the key.
+    ///
+    /// If there are multiple values associated with the key, then the first one
+    /// is returned. Use `entry` to get all values associated with a given
+    /// key. Returns `None` if there are no values associated with the key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::default();
+    /// map.insert(HOST, "hello".to_string());
+    /// map.get_mut("host").unwrap().push_str("-world");
+    ///
+    /// assert_eq!(map.get(HOST).unwrap(), &"hello-world");
+    /// ```
+    pub fn get_mut<K>(&mut self, key: K) -> Option<&mut T>
+    where
+        K: AsHeaderName,
+    {
+        match key.find(self) {
+            Some((_, found)) => {
+                let entry = &mut self.entries[found];
+                Some(&mut entry.value)
+            }
+            None => None,
+        }
+    }
+
+    /// Returns a view of all values associated with a key.
+    ///
+    /// The returned view does not incur any allocations and allows iterating
+    /// the values associated with the key.  See [`GetAll`] for more details.
+    /// Returns `None` if there are no values associated with the key.
+    ///
+    /// [`GetAll`]: struct.GetAll.html
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.insert(HOST, "hello".parse().unwrap());
+    /// map.append(HOST, "goodbye".parse().unwrap());
+    ///
+    /// let view = map.get_all("host");
+    ///
+    /// let mut iter = view.iter();
+    /// assert_eq!(&"hello", iter.next().unwrap());
+    /// assert_eq!(&"goodbye", iter.next().unwrap());
+    /// assert!(iter.next().is_none());
+    /// ```
+    pub fn get_all<K>(&self, key: K) -> GetAll<'_, T>
+    where
+        K: AsHeaderName,
+    {
+        GetAll {
+            map: self,
+            index: key.find(self).map(|(_, i)| i),
+        }
+    }
+
+    /// Returns true if the map contains a value for the specified key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// assert!(!map.contains_key(HOST));
+    ///
+    /// map.insert(HOST, "world".parse().unwrap());
+    /// assert!(map.contains_key("host"));
+    /// ```
+    pub fn contains_key<K>(&self, key: K) -> bool
+    where
+        K: AsHeaderName,
+    {
+        key.find(self).is_some()
+    }
+
+    /// An iterator visiting all key-value pairs.
+    ///
+    /// The iteration order is arbitrary, but consistent across platforms for
+    /// the same crate version. Each key will be yielded once per associated
+    /// value. So, if a key has 3 associated values, it will be yielded 3 times.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{CONTENT_LENGTH, HOST};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.insert(HOST, "hello".parse().unwrap());
+    /// map.append(HOST, "goodbye".parse().unwrap());
+    /// map.insert(CONTENT_LENGTH, "123".parse().unwrap());
+    ///
+    /// for (key, value) in map.iter() {
+    ///     println!("{:?}: {:?}", key, value);
+    /// }
+    /// ```
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter {
+            inner: IterMut {
+                map: self as *const _ as *mut _,
+                entry: 0,
+                cursor: self.entries.first().map(|_| Cursor::Head),
+                lt: PhantomData,
+            },
+        }
+    }
+
+    /// An iterator visiting all key-value pairs, with mutable value references.
+    ///
+    /// The iterator order is arbitrary, but consistent across platforms for the
+    /// same crate version. Each key will be yielded once per associated value,
+    /// so if a key has 3 associated values, it will be yielded 3 times.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{CONTENT_LENGTH, HOST};
+    /// let mut map = HeaderMap::default();
+    ///
+    /// map.insert(HOST, "hello".to_string());
+    /// map.append(HOST, "goodbye".to_string());
+    /// map.insert(CONTENT_LENGTH, "123".to_string());
+    ///
+    /// for (key, value) in map.iter_mut() {
+    ///     value.push_str("-boop");
+    /// }
+    /// ```
+    pub fn iter_mut(&mut self) -> IterMut<'_, T> {
+        IterMut {
+            map: self as *mut _,
+            entry: 0,
+            cursor: self.entries.first().map(|_| Cursor::Head),
+            lt: PhantomData,
+        }
+    }
+
+    /// An iterator visiting all keys.
+    ///
+    /// The iteration order is arbitrary, but consistent across platforms for
+    /// the same crate version. Each key will be yielded only once even if it
+    /// has multiple associated values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{CONTENT_LENGTH, HOST};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.insert(HOST, "hello".parse().unwrap());
+    /// map.append(HOST, "goodbye".parse().unwrap());
+    /// map.insert(CONTENT_LENGTH, "123".parse().unwrap());
+    ///
+    /// for key in map.keys() {
+    ///     println!("{:?}", key);
+    /// }
+    /// ```
+    pub fn keys(&self) -> Keys<'_, T> {
+        Keys {
+            inner: self.entries.iter(),
+        }
+    }
+
+    /// An iterator visiting all values.
+    ///
+    /// The iteration order is arbitrary, but consistent across platforms for
+    /// the same crate version.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{CONTENT_LENGTH, HOST};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.insert(HOST, "hello".parse().unwrap());
+    /// map.append(HOST, "goodbye".parse().unwrap());
+    /// map.insert(CONTENT_LENGTH, "123".parse().unwrap());
+    ///
+    /// for value in map.values() {
+    ///     println!("{:?}", value);
+    /// }
+    /// ```
+    pub fn values(&self) -> Values<'_, T> {
+        Values { inner: self.iter() }
+    }
+
+    /// An iterator visiting all values mutably.
+    ///
+    /// The iteration order is arbitrary, but consistent across platforms for
+    /// the same crate version.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{CONTENT_LENGTH, HOST};
+    /// let mut map = HeaderMap::default();
+    ///
+    /// map.insert(HOST, "hello".to_string());
+    /// map.append(HOST, "goodbye".to_string());
+    /// map.insert(CONTENT_LENGTH, "123".to_string());
+    ///
+    /// for value in map.values_mut() {
+    ///     value.push_str("-boop");
+    /// }
+    /// ```
+    pub fn values_mut(&mut self) -> ValuesMut<'_, T> {
+        ValuesMut {
+            inner: self.iter_mut(),
+        }
+    }
+
+    /// Clears the map, returning all entries as an iterator.
+    ///
+    /// The internal memory is kept for reuse.
+    ///
+    /// For each yielded item that has `None` provided for the `HeaderName`,
+    /// then the associated header name is the same as that of the previously
+    /// yielded item. The first yielded item will have `HeaderName` set.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::{CONTENT_LENGTH, HOST};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.insert(HOST, "hello".parse().unwrap());
+    /// map.append(HOST, "goodbye".parse().unwrap());
+    /// map.insert(CONTENT_LENGTH, "123".parse().unwrap());
+    ///
+    /// let mut drain = map.drain();
+    ///
+    ///
+    /// assert_eq!(drain.next(), Some((Some(HOST), "hello".parse().unwrap())));
+    /// assert_eq!(drain.next(), Some((None, "goodbye".parse().unwrap())));
+    ///
+    /// assert_eq!(drain.next(), Some((Some(CONTENT_LENGTH), "123".parse().unwrap())));
+    ///
+    /// assert_eq!(drain.next(), None);
+    /// ```
+    pub fn drain(&mut self) -> Drain<'_, T> {
+        for i in self.indices.iter_mut() {
+            *i = Pos::none();
+        }
+
+        // Memory safety
+        //
+        // When the Drain is first created, it shortens the length of
+        // the source vector to make sure no uninitialized or moved-from
+        // elements are accessible at all if the Drain's destructor never
+        // gets to run.
+
+        let entries = &mut self.entries[..] as *mut _;
+        let extra_values = &mut self.extra_values as *mut _;
+        let len = self.entries.len();
+        unsafe { self.entries.set_len(0); }
+
+        Drain {
+            idx: 0,
+            len,
+            entries,
+            extra_values,
+            next: None,
+            lt: PhantomData,
+        }
+    }
+
+    fn value_iter(&self, idx: Option<usize>) -> ValueIter<'_, T> {
+        use self::Cursor::*;
+
+        if let Some(idx) = idx {
+            let back = {
+                let entry = &self.entries[idx];
+
+                entry.links.map(|l| Values(l.tail)).unwrap_or(Head)
+            };
+
+            ValueIter {
+                map: self,
+                index: idx,
+                front: Some(Head),
+                back: Some(back),
+            }
+        } else {
+            ValueIter {
+                map: self,
+                index: ::std::usize::MAX,
+                front: None,
+                back: None,
+            }
+        }
+    }
+
+    fn value_iter_mut(&mut self, idx: usize) -> ValueIterMut<'_, T> {
+        use self::Cursor::*;
+
+        let back = {
+            let entry = &self.entries[idx];
+
+            entry.links.map(|l| Values(l.tail)).unwrap_or(Head)
+        };
+
+        ValueIterMut {
+            map: self as *mut _,
+            index: idx,
+            front: Some(Head),
+            back: Some(back),
+            lt: PhantomData,
+        }
+    }
+
+    /// Gets the given key's corresponding entry in the map for in-place
+    /// manipulation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let mut map: HeaderMap<u32> = HeaderMap::default();
+    ///
+    /// let headers = &[
+    ///     "content-length",
+    ///     "x-hello",
+    ///     "Content-Length",
+    ///     "x-world",
+    /// ];
+    ///
+    /// for &header in headers {
+    ///     let counter = map.entry(header).or_insert(0);
+    ///     *counter += 1;
+    /// }
+    ///
+    /// assert_eq!(map["content-length"], 2);
+    /// assert_eq!(map["x-hello"], 1);
+    /// ```
+    pub fn entry<K>(&mut self, key: K) -> Entry<'_, T>
+    where
+        K: IntoHeaderName,
+    {
+        key.entry(self)
+    }
+
+    /// Gets the given key's corresponding entry in the map for in-place
+    /// manipulation.
+    ///
+    /// # Errors
+    ///
+    /// This method differs from `entry` by allowing types that may not be
+    /// valid `HeaderName`s to passed as the key (such as `String`). If they
+    /// do not parse as a valid `HeaderName`, this returns an
+    /// `InvalidHeaderName` error.
+    pub fn try_entry<K>(&mut self, key: K) -> Result<Entry<'_, T>, InvalidHeaderName>
+    where
+        K: AsHeaderName,
+    {
+        key.try_entry(self)
+    }
+
+    fn entry2<K>(&mut self, key: K) -> Entry<'_, T>
+    where
+        K: Hash + Into<HeaderName>,
+        HeaderName: PartialEq<K>,
+    {
+        // Ensure that there is space in the map
+        self.reserve_one();
+
+        insert_phase_one!(
+            self,
+            key,
+            probe,
+            pos,
+            hash,
+            danger,
+            Entry::Vacant(VacantEntry {
+                map: self,
+                hash: hash,
+                key: key.into(),
+                probe: probe,
+                danger: danger,
+            }),
+            Entry::Occupied(OccupiedEntry {
+                map: self,
+                index: pos,
+                probe: probe,
+            }),
+            Entry::Vacant(VacantEntry {
+                map: self,
+                hash: hash,
+                key: key.into(),
+                probe: probe,
+                danger: danger,
+            })
+        )
+    }
+
+    /// Inserts a key-value pair into the map.
+    ///
+    /// If the map did not previously have this key present, then `None` is
+    /// returned.
+    ///
+    /// If the map did have this key present, the new value is associated with
+    /// the key and all previous values are removed. **Note** that only a single
+    /// one of the previous values is returned. If there are multiple values
+    /// that have been previously associated with the key, then the first one is
+    /// returned. See `insert_mult` on `OccupiedEntry` for an API that returns
+    /// all values.
+    ///
+    /// The key is not updated, though; this matters for types that can be `==`
+    /// without being identical.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// assert!(map.insert(HOST, "world".parse().unwrap()).is_none());
+    /// assert!(!map.is_empty());
+    ///
+    /// let mut prev = map.insert(HOST, "earth".parse().unwrap()).unwrap();
+    /// assert_eq!("world", prev);
+    /// ```
+    pub fn insert<K>(&mut self, key: K, val: T) -> Option<T>
+    where
+        K: IntoHeaderName,
+    {
+        key.insert(self, val)
+    }
+
+    #[inline]
+    fn insert2<K>(&mut self, key: K, value: T) -> Option<T>
+    where
+        K: Hash + Into<HeaderName>,
+        HeaderName: PartialEq<K>,
+    {
+        self.reserve_one();
+
+        insert_phase_one!(
+            self,
+            key,
+            probe,
+            pos,
+            hash,
+            danger,
+            // Vacant
+            {
+                drop(danger); // Make lint happy
+                let index = self.entries.len();
+                self.insert_entry(hash, key.into(), value);
+                self.indices[probe] = Pos::new(index, hash);
+                None
+            },
+            // Occupied
+            Some(self.insert_occupied(pos, value)),
+            // Robinhood
+            {
+                self.insert_phase_two(key.into(), value, hash, probe, danger);
+                None
+            }
+        )
+    }
+
+    /// Set an occupied bucket to the given value
+    #[inline]
+    fn insert_occupied(&mut self, index: usize, value: T) -> T {
+        if let Some(links) = self.entries[index].links {
+            self.remove_all_extra_values(links.next);
+        }
+
+        let entry = &mut self.entries[index];
+        mem::replace(&mut entry.value, value)
+    }
+
+    fn insert_occupied_mult(&mut self, index: usize, value: T) -> ValueDrain<'_, T> {
+        let old;
+        let links;
+
+        {
+            let entry = &mut self.entries[index];
+
+            old = mem::replace(&mut entry.value, value);
+            links = entry.links.take();
+        }
+
+        let raw_links = self.raw_links();
+        let extra_values = &mut self.extra_values;
+
+        let next = links.map(|l| {
+            drain_all_extra_values(raw_links, extra_values, l.next)
+                .into_iter()
+        });
+
+        ValueDrain {
+            first: Some(old),
+            next: next,
+            lt: PhantomData,
+        }
+    }
+
+    /// Inserts a key-value pair into the map.
+    ///
+    /// If the map did not previously have this key present, then `false` is
+    /// returned.
+    ///
+    /// If the map did have this key present, the new value is pushed to the end
+    /// of the list of values currently associated with the key. The key is not
+    /// updated, though; this matters for types that can be `==` without being
+    /// identical.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// assert!(map.insert(HOST, "world".parse().unwrap()).is_none());
+    /// assert!(!map.is_empty());
+    ///
+    /// map.append(HOST, "earth".parse().unwrap());
+    ///
+    /// let values = map.get_all("host");
+    /// let mut i = values.iter();
+    /// assert_eq!("world", *i.next().unwrap());
+    /// assert_eq!("earth", *i.next().unwrap());
+    /// ```
+    pub fn append<K>(&mut self, key: K, value: T) -> bool
+    where
+        K: IntoHeaderName,
+    {
+        key.append(self, value)
+    }
+
+    #[inline]
+    fn append2<K>(&mut self, key: K, value: T) -> bool
+    where
+        K: Hash + Into<HeaderName>,
+        HeaderName: PartialEq<K>,
+    {
+        self.reserve_one();
+
+        insert_phase_one!(
+            self,
+            key,
+            probe,
+            pos,
+            hash,
+            danger,
+            // Vacant
+            {
+                drop(danger);
+                let index = self.entries.len();
+                self.insert_entry(hash, key.into(), value);
+                self.indices[probe] = Pos::new(index, hash);
+                false
+            },
+            // Occupied
+            {
+                append_value(pos, &mut self.entries[pos], &mut self.extra_values, value);
+                true
+            },
+            // Robinhood
+            {
+                self.insert_phase_two(key.into(), value, hash, probe, danger);
+
+                false
+            }
+        )
+    }
+
+    #[inline]
+    fn find<K: ?Sized>(&self, key: &K) -> Option<(usize, usize)>
+    where
+        K: Hash + Into<HeaderName>,
+        HeaderName: PartialEq<K>,
+    {
+        if self.entries.is_empty() {
+            return None;
+        }
+
+        let hash = hash_elem_using(&self.danger, key);
+        let mask = self.mask;
+        let mut probe = desired_pos(mask, hash);
+        let mut dist = 0;
+
+        probe_loop!(probe < self.indices.len(), {
+            if let Some((i, entry_hash)) = self.indices[probe].resolve() {
+                if dist > probe_distance(mask, entry_hash, probe) {
+                    // give up when probe distance is too long
+                    return None;
+                } else if entry_hash == hash && self.entries[i].key == *key {
+                    return Some((probe, i));
+                }
+            } else {
+                return None;
+            }
+
+            dist += 1;
+        });
+    }
+
+    /// phase 2 is post-insert where we forward-shift `Pos` in the indices.
+    #[inline]
+    fn insert_phase_two(
+        &mut self,
+        key: HeaderName,
+        value: T,
+        hash: HashValue,
+        probe: usize,
+        danger: bool,
+    ) -> usize {
+        // Push the value and get the index
+        let index = self.entries.len();
+        self.insert_entry(hash, key, value);
+
+        let num_displaced = do_insert_phase_two(&mut self.indices, probe, Pos::new(index, hash));
+
+        if danger || num_displaced >= DISPLACEMENT_THRESHOLD {
+            // Increase danger level
+            self.danger.to_yellow();
+        }
+
+        index
+    }
+
+    /// Removes a key from the map, returning the value associated with the key.
+    ///
+    /// Returns `None` if the map does not contain the key. If there are
+    /// multiple values associated with the key, then the first one is returned.
+    /// See `remove_entry_mult` on `OccupiedEntry` for an API that yields all
+    /// values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    ///
+    /// let prev = map.remove(HOST).unwrap();
+    /// assert_eq!("hello.world", prev);
+    ///
+    /// assert!(map.remove(HOST).is_none());
+    /// ```
+    pub fn remove<K>(&mut self, key: K) -> Option<T>
+    where
+        K: AsHeaderName,
+    {
+        match key.find(self) {
+            Some((probe, idx)) => {
+                if let Some(links) = self.entries[idx].links {
+                    self.remove_all_extra_values(links.next);
+                }
+
+                let entry = self.remove_found(probe, idx);
+
+                Some(entry.value)
+            }
+            None => None,
+        }
+    }
+
+    /// Remove an entry from the map.
+    ///
+    /// Warning: To avoid inconsistent state, extra values _must_ be removed
+    /// for the `found` index (via `remove_all_extra_values` or similar)
+    /// _before_ this method is called.
+    #[inline]
+    fn remove_found(&mut self, probe: usize, found: usize) -> Bucket<T> {
+        // index `probe` and entry `found` is to be removed
+        // use swap_remove, but then we need to update the index that points
+        // to the other entry that has to move
+        self.indices[probe] = Pos::none();
+        let entry = self.entries.swap_remove(found);
+
+        // correct index that points to the entry that had to swap places
+        if let Some(entry) = self.entries.get(found) {
+            // was not last element
+            // examine new element in `found` and find it in indices
+            let mut probe = desired_pos(self.mask, entry.hash);
+
+            probe_loop!(probe < self.indices.len(), {
+                if let Some((i, _)) = self.indices[probe].resolve() {
+                    if i >= self.entries.len() {
+                        // found it
+                        self.indices[probe] = Pos::new(found, entry.hash);
+                        break;
+                    }
+                }
+            });
+
+            // Update links
+            if let Some(links) = entry.links {
+                self.extra_values[links.next].prev = Link::Entry(found);
+                self.extra_values[links.tail].next = Link::Entry(found);
+            }
+        }
+
+        // backward shift deletion in self.indices
+        // after probe, shift all non-ideally placed indices backward
+        if self.entries.len() > 0 {
+            let mut last_probe = probe;
+            let mut probe = probe + 1;
+
+            probe_loop!(probe < self.indices.len(), {
+                if let Some((_, entry_hash)) = self.indices[probe].resolve() {
+                    if probe_distance(self.mask, entry_hash, probe) > 0 {
+                        self.indices[last_probe] = self.indices[probe];
+                        self.indices[probe] = Pos::none();
+                    } else {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+
+                last_probe = probe;
+            });
+        }
+
+        entry
+    }
+
+    /// Removes the `ExtraValue` at the given index.
+    #[inline]
+    fn remove_extra_value(&mut self, idx: usize) -> ExtraValue<T> {
+        let raw_links = self.raw_links();
+        remove_extra_value(raw_links, &mut self.extra_values, idx)
+    }
+
+    fn remove_all_extra_values(&mut self, mut head: usize) {
+        loop {
+            let extra = self.remove_extra_value(head);
+
+            if let Link::Extra(idx) = extra.next {
+                head = idx;
+            } else {
+                break;
+            }
+        }
+    }
+
+    #[inline]
+    fn insert_entry(&mut self, hash: HashValue, key: HeaderName, value: T) {
+        assert!(self.entries.len() < MAX_SIZE, "header map at capacity");
+
+        self.entries.push(Bucket {
+            hash: hash,
+            key: key,
+            value: value,
+            links: None,
+        });
+    }
+
+    fn rebuild(&mut self) {
+        // Loop over all entries and re-insert them into the map
+        'outer: for (index, entry) in self.entries.iter_mut().enumerate() {
+            let hash = hash_elem_using(&self.danger, &entry.key);
+            let mut probe = desired_pos(self.mask, hash);
+            let mut dist = 0;
+
+            // Update the entry's hash code
+            entry.hash = hash;
+
+            probe_loop!(probe < self.indices.len(), {
+                if let Some((_, entry_hash)) = self.indices[probe].resolve() {
+                    // if existing element probed less than us, swap
+                    let their_dist = probe_distance(self.mask, entry_hash, probe);
+
+                    if their_dist < dist {
+                        // Robinhood
+                        break;
+                    }
+                } else {
+                    // Vacant slot
+                    self.indices[probe] = Pos::new(index, hash);
+                    continue 'outer;
+                }
+
+                dist += 1;
+            });
+
+            do_insert_phase_two(&mut self.indices, probe, Pos::new(index, hash));
+        }
+    }
+
+    fn reinsert_entry_in_order(&mut self, pos: Pos) {
+        if let Some((_, entry_hash)) = pos.resolve() {
+            // Find first empty bucket and insert there
+            let mut probe = desired_pos(self.mask, entry_hash);
+
+            probe_loop!(probe < self.indices.len(), {
+                if self.indices[probe].resolve().is_none() {
+                    // empty bucket, insert here
+                    self.indices[probe] = pos;
+                    return;
+                }
+            });
+        }
+    }
+
+    fn reserve_one(&mut self) {
+        let len = self.entries.len();
+
+        if self.danger.is_yellow() {
+            let load_factor = self.entries.len() as f32 / self.indices.len() as f32;
+
+            if load_factor >= LOAD_FACTOR_THRESHOLD {
+                // Transition back to green danger level
+                self.danger.to_green();
+
+                // Double the capacity
+                let new_cap = self.indices.len() * 2;
+
+                // Grow the capacity
+                self.grow(new_cap);
+            } else {
+                self.danger.to_red();
+
+                // Rebuild hash table
+                for index in self.indices.iter_mut() {
+                    *index = Pos::none();
+                }
+
+                self.rebuild();
+            }
+        } else if len == self.capacity() {
+            if len == 0 {
+                let new_raw_cap = 8;
+                self.mask = 8 - 1;
+                self.indices = vec![Pos::none(); new_raw_cap].into_boxed_slice();
+                self.entries = Vec::with_capacity(usable_capacity(new_raw_cap));
+            } else {
+                let raw_cap = self.indices.len();
+                self.grow(raw_cap << 1);
+            }
+        }
+    }
+
+    #[inline]
+    fn grow(&mut self, new_raw_cap: usize) {
+        assert!(new_raw_cap <= MAX_SIZE, "requested capacity too large");
+        // This path can never be reached when handling the first allocation in
+        // the map.
+
+        // find first ideally placed element -- start of cluster
+        let mut first_ideal = 0;
+
+        for (i, pos) in self.indices.iter().enumerate() {
+            if let Some((_, entry_hash)) = pos.resolve() {
+                if 0 == probe_distance(self.mask, entry_hash, i) {
+                    first_ideal = i;
+                    break;
+                }
+            }
+        }
+
+        // visit the entries in an order where we can simply reinsert them
+        // into self.indices without any bucket stealing.
+        let old_indices = mem::replace(
+            &mut self.indices,
+            vec![Pos::none(); new_raw_cap].into_boxed_slice(),
+        );
+        self.mask = new_raw_cap.wrapping_sub(1) as Size;
+
+        for &pos in &old_indices[first_ideal..] {
+            self.reinsert_entry_in_order(pos);
+        }
+
+        for &pos in &old_indices[..first_ideal] {
+            self.reinsert_entry_in_order(pos);
+        }
+
+        // Reserve additional entry slots
+        let more = self.capacity() - self.entries.len();
+        self.entries.reserve_exact(more);
+    }
+
+    #[inline]
+    fn raw_links(&mut self) -> RawLinks<T> {
+        RawLinks(&mut self.entries[..] as *mut _)
+    }
+}
+
+/// Removes the `ExtraValue` at the given index.
+#[inline]
+fn remove_extra_value<T>(
+    mut raw_links: RawLinks<T>,
+    extra_values: &mut Vec<ExtraValue<T>>,
+    idx: usize)
+    -> ExtraValue<T>
+{
+    let prev;
+    let next;
+
+    {
+        debug_assert!(extra_values.len() > idx);
+        let extra = &extra_values[idx];
+        prev = extra.prev;
+        next = extra.next;
+    }
+
+    // First unlink the extra value
+    match (prev, next) {
+        (Link::Entry(prev), Link::Entry(next)) => {
+            debug_assert_eq!(prev, next);
+
+            raw_links[prev] = None;
+        }
+        (Link::Entry(prev), Link::Extra(next)) => {
+            debug_assert!(raw_links[prev].is_some());
+
+            raw_links[prev].as_mut().unwrap()
+                .next = next;
+
+            debug_assert!(extra_values.len() > next);
+            extra_values[next].prev = Link::Entry(prev);
+        }
+        (Link::Extra(prev), Link::Entry(next)) => {
+            debug_assert!(raw_links[next].is_some());
+
+            raw_links[next].as_mut().unwrap()
+                .tail = prev;
+
+            debug_assert!(extra_values.len() > prev);
+            extra_values[prev].next = Link::Entry(next);
+        }
+        (Link::Extra(prev), Link::Extra(next)) => {
+            debug_assert!(extra_values.len() > next);
+            debug_assert!(extra_values.len() > prev);
+
+            extra_values[prev].next = Link::Extra(next);
+            extra_values[next].prev = Link::Extra(prev);
+        }
+    }
+
+    // Remove the extra value
+    let mut extra = extra_values.swap_remove(idx);
+
+    // This is the index of the value that was moved (possibly `extra`)
+    let old_idx = extra_values.len();
+
+    // Update the links
+    if extra.prev == Link::Extra(old_idx) {
+        extra.prev = Link::Extra(idx);
+    }
+
+    if extra.next == Link::Extra(old_idx) {
+        extra.next = Link::Extra(idx);
+    }
+
+    // Check if another entry was displaced. If it was, then the links
+    // need to be fixed.
+    if idx != old_idx {
+        let next;
+        let prev;
+
+        {
+            debug_assert!(extra_values.len() > idx);
+            let moved = &extra_values[idx];
+            next = moved.next;
+            prev = moved.prev;
+        }
+
+        // An entry was moved, we have to the links
+        match prev {
+            Link::Entry(entry_idx) => {
+                // It is critical that we do not attempt to read the
+                // header name or value as that memory may have been
+                // "released" already.
+                debug_assert!(raw_links[entry_idx].is_some());
+
+                let links = raw_links[entry_idx].as_mut().unwrap();
+                links.next = idx;
+            }
+            Link::Extra(extra_idx) => {
+                debug_assert!(extra_values.len() > extra_idx);
+                extra_values[extra_idx].next = Link::Extra(idx);
+            }
+        }
+
+        match next {
+            Link::Entry(entry_idx) => {
+                debug_assert!(raw_links[entry_idx].is_some());
+
+                let links = raw_links[entry_idx].as_mut().unwrap();
+                links.tail = idx;
+            }
+            Link::Extra(extra_idx) => {
+                debug_assert!(extra_values.len() > extra_idx);
+                extra_values[extra_idx].prev = Link::Extra(idx);
+            }
+        }
+    }
+
+    debug_assert!({
+        for v in &*extra_values {
+            assert!(v.next != Link::Extra(old_idx));
+            assert!(v.prev != Link::Extra(old_idx));
+        }
+
+        true
+    });
+
+    extra
+}
+
+fn drain_all_extra_values<T>(
+    raw_links: RawLinks<T>,
+    extra_values: &mut Vec<ExtraValue<T>>,
+    mut head: usize)
+    -> Vec<T>
+{
+    let mut vec = Vec::new();
+    loop {
+        let extra = remove_extra_value(raw_links, extra_values, head);
+        vec.push(extra.value);
+
+        if let Link::Extra(idx) = extra.next {
+            head = idx;
+        } else {
+            break;
+        }
+    }
+    vec
+}
+
+impl<'a, T> IntoIterator for &'a HeaderMap<T> {
+    type Item = (&'a HeaderName, &'a T);
+    type IntoIter = Iter<'a, T>;
+
+    fn into_iter(self) -> Iter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a mut HeaderMap<T> {
+    type Item = (&'a HeaderName, &'a mut T);
+    type IntoIter = IterMut<'a, T>;
+
+    fn into_iter(self) -> IterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
+impl<T> IntoIterator for HeaderMap<T> {
+    type Item = (Option<HeaderName>, T);
+    type IntoIter = IntoIter<T>;
+
+    /// Creates a consuming iterator, that is, one that moves keys and values
+    /// out of the map in arbitrary order. The map cannot be used after calling
+    /// this.
+    ///
+    /// For each yielded item that has `None` provided for the `HeaderName`,
+    /// then the associated header name is the same as that of the previously
+    /// yielded item. The first yielded item will have `HeaderName` set.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage.
+    ///
+    /// ```
+    /// # use http::header;
+    /// # use http::header::*;
+    /// let mut map = HeaderMap::new();
+    /// map.insert(header::CONTENT_LENGTH, "123".parse().unwrap());
+    /// map.insert(header::CONTENT_TYPE, "json".parse().unwrap());
+    ///
+    /// let mut iter = map.into_iter();
+    /// assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap())));
+    /// assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap())));
+    /// assert!(iter.next().is_none());
+    /// ```
+    ///
+    /// Multiple values per key.
+    ///
+    /// ```
+    /// # use http::header;
+    /// # use http::header::*;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.append(header::CONTENT_LENGTH, "123".parse().unwrap());
+    /// map.append(header::CONTENT_LENGTH, "456".parse().unwrap());
+    ///
+    /// map.append(header::CONTENT_TYPE, "json".parse().unwrap());
+    /// map.append(header::CONTENT_TYPE, "html".parse().unwrap());
+    /// map.append(header::CONTENT_TYPE, "xml".parse().unwrap());
+    ///
+    /// let mut iter = map.into_iter();
+    ///
+    /// assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap())));
+    /// assert_eq!(iter.next(), Some((None, "456".parse().unwrap())));
+    ///
+    /// assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap())));
+    /// assert_eq!(iter.next(), Some((None, "html".parse().unwrap())));
+    /// assert_eq!(iter.next(), Some((None, "xml".parse().unwrap())));
+    /// assert!(iter.next().is_none());
+    /// ```
+    fn into_iter(self) -> IntoIter<T> {
+        IntoIter {
+            next: None,
+            entries: self.entries.into_iter(),
+            extra_values: self.extra_values,
+        }
+    }
+}
+
+impl<T> FromIterator<(HeaderName, T)> for HeaderMap<T> {
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = (HeaderName, T)>,
+    {
+        let mut map = HeaderMap::default();
+        map.extend(iter);
+        map
+    }
+}
+
+/// Try to convert a `HashMap` into a `HeaderMap`.
+///
+/// # Examples
+///
+/// ```
+/// use std::collections::HashMap;
+/// use std::convert::TryInto;
+/// use http::HeaderMap;
+///
+/// let mut map = HashMap::new();
+/// map.insert("X-Custom-Header".to_string(), "my value".to_string());
+///
+/// let headers: HeaderMap = (&map).try_into().expect("valid headers");
+/// assert_eq!(headers["X-Custom-Header"], "my value");
+/// ```
+impl<'a, K, V, T> TryFrom<&'a HashMap<K, V>> for HeaderMap<T>
+    where
+        K: Eq + Hash,
+        HeaderName: TryFrom<&'a K>,
+        <HeaderName as TryFrom<&'a K>>::Error: Into<crate::Error>,
+        T: TryFrom<&'a V>,
+        T::Error: Into<crate::Error>,
+{
+    type Error = Error;
+
+    fn try_from(c: &'a HashMap<K, V>) -> Result<Self, Self::Error> {
+        c.into_iter()
+            .map(|(k, v)| -> crate::Result<(HeaderName, T)> {
+                let name = TryFrom::try_from(k).map_err(Into::into)?;
+                let value = TryFrom::try_from(v).map_err(Into::into)?;
+                Ok((name, value))
+            })
+            .collect()
+    }
+}
+
+impl<T> Extend<(Option<HeaderName>, T)> for HeaderMap<T> {
+    /// Extend a `HeaderMap` with the contents of another `HeaderMap`.
+    ///
+    /// This function expects the yielded items to follow the same structure as
+    /// `IntoIter`.
+    ///
+    /// # Panics
+    ///
+    /// This panics if the first yielded item does not have a `HeaderName`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::*;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// map.insert(ACCEPT, "text/plain".parse().unwrap());
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    ///
+    /// let mut extra = HeaderMap::new();
+    ///
+    /// extra.insert(HOST, "foo.bar".parse().unwrap());
+    /// extra.insert(COOKIE, "hello".parse().unwrap());
+    /// extra.append(COOKIE, "world".parse().unwrap());
+    ///
+    /// map.extend(extra);
+    ///
+    /// assert_eq!(map["host"], "foo.bar");
+    /// assert_eq!(map["accept"], "text/plain");
+    /// assert_eq!(map["cookie"], "hello");
+    ///
+    /// let v = map.get_all("host");
+    /// assert_eq!(1, v.iter().count());
+    ///
+    /// let v = map.get_all("cookie");
+    /// assert_eq!(2, v.iter().count());
+    /// ```
+    fn extend<I: IntoIterator<Item = (Option<HeaderName>, T)>>(&mut self, iter: I) {
+        let mut iter = iter.into_iter();
+
+        // The structure of this is a bit weird, but it is mostly to make the
+        // borrow checker happy.
+        let (mut key, mut val) = match iter.next() {
+            Some((Some(key), val)) => (key, val),
+            Some((None, _)) => panic!("expected a header name, but got None"),
+            None => return,
+        };
+
+        'outer: loop {
+            let mut entry = match self.entry2(key) {
+                Entry::Occupied(mut e) => {
+                    // Replace all previous values while maintaining a handle to
+                    // the entry.
+                    e.insert(val);
+                    e
+                }
+                Entry::Vacant(e) => e.insert_entry(val),
+            };
+
+            // As long as `HeaderName` is none, keep inserting the value into
+            // the current entry
+            loop {
+                match iter.next() {
+                    Some((Some(k), v)) => {
+                        key = k;
+                        val = v;
+                        continue 'outer;
+                    }
+                    Some((None, v)) => {
+                        entry.append(v);
+                    }
+                    None => {
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<T> Extend<(HeaderName, T)> for HeaderMap<T> {
+    fn extend<I: IntoIterator<Item = (HeaderName, T)>>(&mut self, iter: I) {
+        // Keys may be already present or show multiple times in the iterator.
+        // Reserve the entire hint lower bound if the map is empty.
+        // Otherwise reserve half the hint (rounded up), so the map
+        // will only resize twice in the worst case.
+        let iter = iter.into_iter();
+
+        let reserve = if self.is_empty() {
+            iter.size_hint().0
+        } else {
+            (iter.size_hint().0 + 1) / 2
+        };
+
+        self.reserve(reserve);
+
+        for (k, v) in iter {
+            self.append(k, v);
+        }
+    }
+}
+
+impl<T: PartialEq> PartialEq for HeaderMap<T> {
+    fn eq(&self, other: &HeaderMap<T>) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+
+        self.keys()
+            .all(|key| self.get_all(key) == other.get_all(key))
+    }
+}
+
+impl<T: Eq> Eq for HeaderMap<T> {}
+
+impl<T: fmt::Debug> fmt::Debug for HeaderMap<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_map().entries(self.iter()).finish()
+    }
+}
+
+impl<T> Default for HeaderMap<T> {
+    fn default() -> Self {
+        HeaderMap::with_capacity(0)
+    }
+}
+
+impl<'a, K, T> ops::Index<K> for HeaderMap<T>
+where
+    K: AsHeaderName,
+{
+    type Output = T;
+
+    /// # Panics
+    /// Using the index operator will cause a panic if the header you're querying isn't set.
+    #[inline]
+    fn index(&self, index: K) -> &T {
+        match self.get2(&index) {
+            Some(val) => val,
+            None => panic!("no entry found for key {:?}", index.as_str()),
+        }
+    }
+}
+
+/// phase 2 is post-insert where we forward-shift `Pos` in the indices.
+///
+/// returns the number of displaced elements
+#[inline]
+fn do_insert_phase_two(indices: &mut [Pos], mut probe: usize, mut old_pos: Pos) -> usize {
+    let mut num_displaced = 0;
+
+    probe_loop!(probe < indices.len(), {
+        let pos = &mut indices[probe];
+
+        if pos.is_none() {
+            *pos = old_pos;
+            break;
+        } else {
+            num_displaced += 1;
+            old_pos = mem::replace(pos, old_pos);
+        }
+    });
+
+    num_displaced
+}
+
+#[inline]
+fn append_value<T>(
+    entry_idx: usize,
+    entry: &mut Bucket<T>,
+    extra: &mut Vec<ExtraValue<T>>,
+    value: T,
+) {
+    match entry.links {
+        Some(links) => {
+            let idx = extra.len();
+            extra.push(ExtraValue {
+                value: value,
+                prev: Link::Extra(links.tail),
+                next: Link::Entry(entry_idx),
+            });
+
+            extra[links.tail].next = Link::Extra(idx);
+
+            entry.links = Some(Links { tail: idx, ..links });
+        }
+        None => {
+            let idx = extra.len();
+            extra.push(ExtraValue {
+                value: value,
+                prev: Link::Entry(entry_idx),
+                next: Link::Entry(entry_idx),
+            });
+
+            entry.links = Some(Links {
+                next: idx,
+                tail: idx,
+            });
+        }
+    }
+}
+
+// ===== impl Iter =====
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = (&'a HeaderName, &'a T);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner
+            .next_unsafe()
+            .map(|(key, ptr)| (key, unsafe { &*ptr }))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<'a, T> FusedIterator for Iter<'a, T> {}
+
+unsafe impl<'a, T: Sync> Sync for Iter<'a, T> {}
+unsafe impl<'a, T: Sync> Send for Iter<'a, T> {}
+
+// ===== impl IterMut =====
+
+impl<'a, T> IterMut<'a, T> {
+    fn next_unsafe(&mut self) -> Option<(&'a HeaderName, *mut T)> {
+        use self::Cursor::*;
+
+        if self.cursor.is_none() {
+            if (self.entry + 1) >= unsafe { &*self.map }.entries.len() {
+                return None;
+            }
+
+            self.entry += 1;
+            self.cursor = Some(Cursor::Head);
+        }
+
+        let entry = unsafe { &(*self.map).entries[self.entry] };
+
+        match self.cursor.unwrap() {
+            Head => {
+                self.cursor = entry.links.map(|l| Values(l.next));
+                Some((&entry.key, &entry.value as *const _ as *mut _))
+            }
+            Values(idx) => {
+                let extra = unsafe { &(*self.map).extra_values[idx] };
+
+                match extra.next {
+                    Link::Entry(_) => self.cursor = None,
+                    Link::Extra(i) => self.cursor = Some(Values(i)),
+                }
+
+                Some((&entry.key, &extra.value as *const _ as *mut _))
+            }
+        }
+    }
+}
+
+impl<'a, T> Iterator for IterMut<'a, T> {
+    type Item = (&'a HeaderName, &'a mut T);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next_unsafe()
+            .map(|(key, ptr)| (key, unsafe { &mut *ptr }))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let map = unsafe { &*self.map };
+        debug_assert!(map.entries.len() >= self.entry);
+
+        let lower = map.entries.len() - self.entry;
+        // We could pessimistically guess at the upper bound, saying
+        // that its lower + map.extra_values.len(). That could be
+        // way over though, such as if we're near the end, and have
+        // already gone through several extra values...
+        (lower, None)
+    }
+}
+
+impl<'a, T> FusedIterator for IterMut<'a, T> {}
+
+unsafe impl<'a, T: Sync> Sync for IterMut<'a, T> {}
+unsafe impl<'a, T: Send> Send for IterMut<'a, T> {}
+
+// ===== impl Keys =====
+
+impl<'a, T> Iterator for Keys<'a, T> {
+    type Item = &'a HeaderName;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|b| &b.key)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<'a, T> ExactSizeIterator for Keys<'a, T> {}
+impl<'a, T> FusedIterator for Keys<'a, T> {}
+
+// ===== impl Values ====
+
+impl<'a, T> Iterator for Values<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|(_, v)| v)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<'a, T> FusedIterator for Values<'a, T> {}
+
+// ===== impl ValuesMut ====
+
+impl<'a, T> Iterator for ValuesMut<'a, T> {
+    type Item = &'a mut T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|(_, v)| v)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<'a, T> FusedIterator for ValuesMut<'a, T> {}
+
+// ===== impl Drain =====
+
+impl<'a, T> Iterator for Drain<'a, T> {
+    type Item = (Option<HeaderName>, T);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(next) = self.next {
+            // Remove the extra value
+
+            let raw_links = RawLinks(self.entries);
+            let extra = unsafe {
+                remove_extra_value(raw_links, &mut *self.extra_values, next)
+            };
+
+            match extra.next {
+                Link::Extra(idx) => self.next = Some(idx),
+                Link::Entry(_) => self.next = None,
+            }
+
+            return Some((None, extra.value));
+        }
+
+        let idx = self.idx;
+
+        if idx == self.len {
+            return None;
+        }
+
+        self.idx += 1;
+
+        unsafe {
+            let entry = &(*self.entries)[idx];
+
+            // Read the header name
+            let key = ptr::read(&entry.key as *const _);
+            let value = ptr::read(&entry.value as *const _);
+            self.next = entry.links.map(|l| l.next);
+
+            Some((Some(key), value))
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        // At least this many names... It's unknown if the user wants
+        // to count the extra_values on top.
+        //
+        // For instance, extending a new `HeaderMap` wouldn't need to
+        // reserve the upper-bound in `entries`, only the lower-bound.
+        let lower = self.len - self.idx;
+        let upper = unsafe { (*self.extra_values).len() } + lower;
+        (lower, Some(upper))
+    }
+}
+
+impl<'a, T> FusedIterator for Drain<'a, T> {}
+
+impl<'a, T> Drop for Drain<'a, T> {
+    fn drop(&mut self) {
+        for _ in self {}
+    }
+}
+
+unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}
+unsafe impl<'a, T: Send> Send for Drain<'a, T> {}
+
+// ===== impl Entry =====
+
+impl<'a, T> Entry<'a, T> {
+    /// Ensures a value is in the entry by inserting the default if empty.
+    ///
+    /// Returns a mutable reference to the **first** value in the entry.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let mut map: HeaderMap<u32> = HeaderMap::default();
+    ///
+    /// let headers = &[
+    ///     "content-length",
+    ///     "x-hello",
+    ///     "Content-Length",
+    ///     "x-world",
+    /// ];
+    ///
+    /// for &header in headers {
+    ///     let counter = map.entry(header)
+    ///         .or_insert(0);
+    ///     *counter += 1;
+    /// }
+    ///
+    /// assert_eq!(map["content-length"], 2);
+    /// assert_eq!(map["x-hello"], 1);
+    /// ```
+    pub fn or_insert(self, default: T) -> &'a mut T {
+        use self::Entry::*;
+
+        match self {
+            Occupied(e) => e.into_mut(),
+            Vacant(e) => e.insert(default),
+        }
+    }
+
+    /// Ensures a value is in the entry by inserting the result of the default
+    /// function if empty.
+    ///
+    /// The default function is not called if the entry exists in the map.
+    /// Returns a mutable reference to the **first** value in the entry.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage.
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// let res = map.entry("x-hello")
+    ///     .or_insert_with(|| "world".parse().unwrap());
+    ///
+    /// assert_eq!(res, "world");
+    /// ```
+    ///
+    /// The default function is not called if the entry exists in the map.
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    ///
+    /// let res = map.entry("host")
+    ///     .or_insert_with(|| unreachable!());
+    ///
+    ///
+    /// assert_eq!(res, "world");
+    /// ```
+    pub fn or_insert_with<F: FnOnce() -> T>(self, default: F) -> &'a mut T {
+        use self::Entry::*;
+
+        match self {
+            Occupied(e) => e.into_mut(),
+            Vacant(e) => e.insert(default()),
+        }
+    }
+
+    /// Returns a reference to the entry's key
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// assert_eq!(map.entry("x-hello").key(), "x-hello");
+    /// ```
+    pub fn key(&self) -> &HeaderName {
+        use self::Entry::*;
+
+        match *self {
+            Vacant(ref e) => e.key(),
+            Occupied(ref e) => e.key(),
+        }
+    }
+}
+
+// ===== impl VacantEntry =====
+
+impl<'a, T> VacantEntry<'a, T> {
+    /// Returns a reference to the entry's key
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// assert_eq!(map.entry("x-hello").key().as_str(), "x-hello");
+    /// ```
+    pub fn key(&self) -> &HeaderName {
+        &self.key
+    }
+
+    /// Take ownership of the key
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// if let Entry::Vacant(v) = map.entry("x-hello") {
+    ///     assert_eq!(v.into_key().as_str(), "x-hello");
+    /// }
+    /// ```
+    pub fn into_key(self) -> HeaderName {
+        self.key
+    }
+
+    /// Insert the value into the entry.
+    ///
+    /// The value will be associated with this entry's key. A mutable reference
+    /// to the inserted value will be returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry};
+    /// let mut map = HeaderMap::new();
+    ///
+    /// if let Entry::Vacant(v) = map.entry("x-hello") {
+    ///     v.insert("world".parse().unwrap());
+    /// }
+    ///
+    /// assert_eq!(map["x-hello"], "world");
+    /// ```
+    pub fn insert(self, value: T) -> &'a mut T {
+        // Ensure that there is space in the map
+        let index =
+            self.map
+                .insert_phase_two(self.key, value.into(), self.hash, self.probe, self.danger);
+
+        &mut self.map.entries[index].value
+    }
+
+    /// Insert the value into the entry.
+    ///
+    /// The value will be associated with this entry's key. The new
+    /// `OccupiedEntry` is returned, allowing for further manipulation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::*;
+    /// let mut map = HeaderMap::new();
+    ///
+    /// if let Entry::Vacant(v) = map.entry("x-hello") {
+    ///     let mut e = v.insert_entry("world".parse().unwrap());
+    ///     e.insert("world2".parse().unwrap());
+    /// }
+    ///
+    /// assert_eq!(map["x-hello"], "world2");
+    /// ```
+    pub fn insert_entry(self, value: T) -> OccupiedEntry<'a, T> {
+        // Ensure that there is space in the map
+        let index =
+            self.map
+                .insert_phase_two(self.key, value.into(), self.hash, self.probe, self.danger);
+
+        OccupiedEntry {
+            map: self.map,
+            index: index,
+            probe: self.probe,
+        }
+    }
+}
+
+// ===== impl GetAll =====
+
+impl<'a, T: 'a> GetAll<'a, T> {
+    /// Returns an iterator visiting all values associated with the entry.
+    ///
+    /// Values are iterated in insertion order.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::HeaderMap;
+    /// # use http::header::HOST;
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    /// map.append(HOST, "hello.earth".parse().unwrap());
+    ///
+    /// let values = map.get_all("host");
+    /// let mut iter = values.iter();
+    /// assert_eq!(&"hello.world", iter.next().unwrap());
+    /// assert_eq!(&"hello.earth", iter.next().unwrap());
+    /// assert!(iter.next().is_none());
+    /// ```
+    pub fn iter(&self) -> ValueIter<'a, T> {
+        // This creates a new GetAll struct so that the lifetime
+        // isn't bound to &self.
+        GetAll {
+            map: self.map,
+            index: self.index,
+        }
+        .into_iter()
+    }
+}
+
+impl<'a, T: PartialEq> PartialEq for GetAll<'a, T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.iter().eq(other.iter())
+    }
+}
+
+impl<'a, T> IntoIterator for GetAll<'a, T> {
+    type Item = &'a T;
+    type IntoIter = ValueIter<'a, T>;
+
+    fn into_iter(self) -> ValueIter<'a, T> {
+        self.map.value_iter(self.index)
+    }
+}
+
+impl<'a, 'b: 'a, T> IntoIterator for &'b GetAll<'a, T> {
+    type Item = &'a T;
+    type IntoIter = ValueIter<'a, T>;
+
+    fn into_iter(self) -> ValueIter<'a, T> {
+        self.map.value_iter(self.index)
+    }
+}
+
+// ===== impl ValueIter =====
+
+impl<'a, T: 'a> Iterator for ValueIter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        use self::Cursor::*;
+
+        match self.front {
+            Some(Head) => {
+                let entry = &self.map.entries[self.index];
+
+                if self.back == Some(Head) {
+                    self.front = None;
+                    self.back = None;
+                } else {
+                    // Update the iterator state
+                    match entry.links {
+                        Some(links) => {
+                            self.front = Some(Values(links.next));
+                        }
+                        None => unreachable!(),
+                    }
+                }
+
+                Some(&entry.value)
+            }
+            Some(Values(idx)) => {
+                let extra = &self.map.extra_values[idx];
+
+                if self.front == self.back {
+                    self.front = None;
+                    self.back = None;
+                } else {
+                    match extra.next {
+                        Link::Entry(_) => self.front = None,
+                        Link::Extra(i) => self.front = Some(Values(i)),
+                    }
+                }
+
+                Some(&extra.value)
+            }
+            None => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match (self.front, self.back) {
+            // Exactly 1 value...
+            (Some(Cursor::Head), Some(Cursor::Head)) => (1, Some(1)),
+            // At least 1...
+            (Some(_), _) => (1, None),
+            // No more values...
+            (None, _) => (0, Some(0)),
+        }
+    }
+}
+
+impl<'a, T: 'a> DoubleEndedIterator for ValueIter<'a, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        use self::Cursor::*;
+
+        match self.back {
+            Some(Head) => {
+                self.front = None;
+                self.back = None;
+                Some(&self.map.entries[self.index].value)
+            }
+            Some(Values(idx)) => {
+                let extra = &self.map.extra_values[idx];
+
+                if self.front == self.back {
+                    self.front = None;
+                    self.back = None;
+                } else {
+                    match extra.prev {
+                        Link::Entry(_) => self.back = Some(Head),
+                        Link::Extra(idx) => self.back = Some(Values(idx)),
+                    }
+                }
+
+                Some(&extra.value)
+            }
+            None => None,
+        }
+    }
+}
+
+impl<'a, T> FusedIterator for ValueIter<'a, T> {}
+
+// ===== impl ValueIterMut =====
+
+impl<'a, T: 'a> Iterator for ValueIterMut<'a, T> {
+    type Item = &'a mut T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        use self::Cursor::*;
+
+        let entry = unsafe { &mut (*self.map).entries[self.index] };
+
+        match self.front {
+            Some(Head) => {
+                if self.back == Some(Head) {
+                    self.front = None;
+                    self.back = None;
+                } else {
+                    // Update the iterator state
+                    match entry.links {
+                        Some(links) => {
+                            self.front = Some(Values(links.next));
+                        }
+                        None => unreachable!(),
+                    }
+                }
+
+                Some(&mut entry.value)
+            }
+            Some(Values(idx)) => {
+                let extra = unsafe { &mut (*self.map).extra_values[idx] };
+
+                if self.front == self.back {
+                    self.front = None;
+                    self.back = None;
+                } else {
+                    match extra.next {
+                        Link::Entry(_) => self.front = None,
+                        Link::Extra(i) => self.front = Some(Values(i)),
+                    }
+                }
+
+                Some(&mut extra.value)
+            }
+            None => None,
+        }
+    }
+}
+
+impl<'a, T: 'a> DoubleEndedIterator for ValueIterMut<'a, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        use self::Cursor::*;
+
+        let entry = unsafe { &mut (*self.map).entries[self.index] };
+
+        match self.back {
+            Some(Head) => {
+                self.front = None;
+                self.back = None;
+                Some(&mut entry.value)
+            }
+            Some(Values(idx)) => {
+                let extra = unsafe { &mut (*self.map).extra_values[idx] };
+
+                if self.front == self.back {
+                    self.front = None;
+                    self.back = None;
+                } else {
+                    match extra.prev {
+                        Link::Entry(_) => self.back = Some(Head),
+                        Link::Extra(idx) => self.back = Some(Values(idx)),
+                    }
+                }
+
+                Some(&mut extra.value)
+            }
+            None => None,
+        }
+    }
+}
+
+impl<'a, T> FusedIterator for ValueIterMut<'a, T> {}
+
+unsafe impl<'a, T: Sync> Sync for ValueIterMut<'a, T> {}
+unsafe impl<'a, T: Send> Send for ValueIterMut<'a, T> {}
+
+// ===== impl IntoIter =====
+
+impl<T> Iterator for IntoIter<T> {
+    type Item = (Option<HeaderName>, T);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(next) = self.next {
+            self.next = match self.extra_values[next].next {
+                Link::Entry(_) => None,
+                Link::Extra(v) => Some(v),
+            };
+
+            let value = unsafe { ptr::read(&self.extra_values[next].value) };
+
+            return Some((None, value));
+        }
+
+        if let Some(bucket) = self.entries.next() {
+            self.next = bucket.links.map(|l| l.next);
+            let name = Some(bucket.key);
+            let value = bucket.value;
+
+            return Some((name, value));
+        }
+
+        None
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let (lower, _) = self.entries.size_hint();
+        // There could be more than just the entries upper, as there
+        // could be items in the `extra_values`. We could guess, saying
+        // `upper + extra_values.len()`, but that could overestimate by a lot.
+        (lower, None)
+    }
+}
+
+impl<T> FusedIterator for IntoIter<T> {}
+
+impl<T> Drop for IntoIter<T> {
+    fn drop(&mut self) {
+        // Ensure the iterator is consumed
+        for _ in self.by_ref() {}
+
+        // All the values have already been yielded out.
+        unsafe {
+            self.extra_values.set_len(0);
+        }
+    }
+}
+
+// ===== impl OccupiedEntry =====
+
+impl<'a, T> OccupiedEntry<'a, T> {
+    /// Returns a reference to the entry's key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(e) = map.entry("host") {
+    ///     assert_eq!("host", e.key());
+    /// }
+    /// ```
+    pub fn key(&self) -> &HeaderName {
+        &self.map.entries[self.index].key
+    }
+
+    /// Get a reference to the first value in the entry.
+    ///
+    /// Values are stored in insertion order.
+    ///
+    /// # Panics
+    ///
+    /// `get` panics if there are no values associated with the entry.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(mut e) = map.entry("host") {
+    ///     assert_eq!(e.get(), &"hello.world");
+    ///
+    ///     e.append("hello.earth".parse().unwrap());
+    ///
+    ///     assert_eq!(e.get(), &"hello.world");
+    /// }
+    /// ```
+    pub fn get(&self) -> &T {
+        &self.map.entries[self.index].value
+    }
+
+    /// Get a mutable reference to the first value in the entry.
+    ///
+    /// Values are stored in insertion order.
+    ///
+    /// # Panics
+    ///
+    /// `get_mut` panics if there are no values associated with the entry.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::default();
+    /// map.insert(HOST, "hello.world".to_string());
+    ///
+    /// if let Entry::Occupied(mut e) = map.entry("host") {
+    ///     e.get_mut().push_str("-2");
+    ///     assert_eq!(e.get(), &"hello.world-2");
+    /// }
+    /// ```
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.map.entries[self.index].value
+    }
+
+    /// Converts the `OccupiedEntry` into a mutable reference to the **first**
+    /// value.
+    ///
+    /// The lifetime of the returned reference is bound to the original map.
+    ///
+    /// # Panics
+    ///
+    /// `into_mut` panics if there are no values associated with the entry.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::default();
+    /// map.insert(HOST, "hello.world".to_string());
+    /// map.append(HOST, "hello.earth".to_string());
+    ///
+    /// if let Entry::Occupied(e) = map.entry("host") {
+    ///     e.into_mut().push_str("-2");
+    /// }
+    ///
+    /// assert_eq!("hello.world-2", map["host"]);
+    /// ```
+    pub fn into_mut(self) -> &'a mut T {
+        &mut self.map.entries[self.index].value
+    }
+
+    /// Sets the value of the entry.
+    ///
+    /// All previous values associated with the entry are removed and the first
+    /// one is returned. See `insert_mult` for an API that returns all values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "hello.world".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(mut e) = map.entry("host") {
+    ///     let mut prev = e.insert("earth".parse().unwrap());
+    ///     assert_eq!("hello.world", prev);
+    /// }
+    ///
+    /// assert_eq!("earth", map["host"]);
+    /// ```
+    pub fn insert(&mut self, value: T) -> T {
+        self.map.insert_occupied(self.index, value.into())
+    }
+
+    /// Sets the value of the entry.
+    ///
+    /// This function does the same as `insert` except it returns an iterator
+    /// that yields all values previously associated with the key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    /// map.append(HOST, "world2".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(mut e) = map.entry("host") {
+    ///     let mut prev = e.insert_mult("earth".parse().unwrap());
+    ///     assert_eq!("world", prev.next().unwrap());
+    ///     assert_eq!("world2", prev.next().unwrap());
+    ///     assert!(prev.next().is_none());
+    /// }
+    ///
+    /// assert_eq!("earth", map["host"]);
+    /// ```
+    pub fn insert_mult(&mut self, value: T) -> ValueDrain<'_, T> {
+        self.map.insert_occupied_mult(self.index, value.into())
+    }
+
+    /// Insert the value into the entry.
+    ///
+    /// The new value is appended to the end of the entry's value list. All
+    /// previous values associated with the entry are retained.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(mut e) = map.entry("host") {
+    ///     e.append("earth".parse().unwrap());
+    /// }
+    ///
+    /// let values = map.get_all("host");
+    /// let mut i = values.iter();
+    /// assert_eq!("world", *i.next().unwrap());
+    /// assert_eq!("earth", *i.next().unwrap());
+    /// ```
+    pub fn append(&mut self, value: T) {
+        let idx = self.index;
+        let entry = &mut self.map.entries[idx];
+        append_value(idx, entry, &mut self.map.extra_values, value.into());
+    }
+
+    /// Remove the entry from the map.
+    ///
+    /// All values associated with the entry are removed and the first one is
+    /// returned. See `remove_entry_mult` for an API that returns all values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(e) = map.entry("host") {
+    ///     let mut prev = e.remove();
+    ///     assert_eq!("world", prev);
+    /// }
+    ///
+    /// assert!(!map.contains_key("host"));
+    /// ```
+    pub fn remove(self) -> T {
+        self.remove_entry().1
+    }
+
+    /// Remove the entry from the map.
+    ///
+    /// The key and all values associated with the entry are removed and the
+    /// first one is returned. See `remove_entry_mult` for an API that returns
+    /// all values.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(e) = map.entry("host") {
+    ///     let (key, mut prev) = e.remove_entry();
+    ///     assert_eq!("host", key.as_str());
+    ///     assert_eq!("world", prev);
+    /// }
+    ///
+    /// assert!(!map.contains_key("host"));
+    /// ```
+    pub fn remove_entry(self) -> (HeaderName, T) {
+        if let Some(links) = self.map.entries[self.index].links {
+            self.map.remove_all_extra_values(links.next);
+        }
+
+        let entry = self.map.remove_found(self.probe, self.index);
+
+        (entry.key, entry.value)
+    }
+
+    /// Remove the entry from the map.
+    ///
+    /// The key and all values associated with the entry are removed and
+    /// returned.
+    pub fn remove_entry_mult(self) -> (HeaderName, ValueDrain<'a, T>) {
+        let raw_links = self.map.raw_links();
+        let extra_values = &mut self.map.extra_values;
+
+        let next = self.map.entries[self.index].links.map(|l| {
+            drain_all_extra_values(raw_links, extra_values, l.next)
+                .into_iter()
+        });
+
+        let entry = self.map.remove_found(self.probe, self.index);
+
+        let drain = ValueDrain {
+            first: Some(entry.value),
+            next,
+            lt: PhantomData,
+        };
+        (entry.key, drain)
+    }
+
+    /// Returns an iterator visiting all values associated with the entry.
+    ///
+    /// Values are iterated in insertion order.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::new();
+    /// map.insert(HOST, "world".parse().unwrap());
+    /// map.append(HOST, "earth".parse().unwrap());
+    ///
+    /// if let Entry::Occupied(e) = map.entry("host") {
+    ///     let mut iter = e.iter();
+    ///     assert_eq!(&"world", iter.next().unwrap());
+    ///     assert_eq!(&"earth", iter.next().unwrap());
+    ///     assert!(iter.next().is_none());
+    /// }
+    /// ```
+    pub fn iter(&self) -> ValueIter<'_, T> {
+        self.map.value_iter(Some(self.index))
+    }
+
+    /// Returns an iterator mutably visiting all values associated with the
+    /// entry.
+    ///
+    /// Values are iterated in insertion order.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderMap, Entry, HOST};
+    /// let mut map = HeaderMap::default();
+    /// map.insert(HOST, "world".to_string());
+    /// map.append(HOST, "earth".to_string());
+    ///
+    /// if let Entry::Occupied(mut e) = map.entry("host") {
+    ///     for e in e.iter_mut() {
+    ///         e.push_str("-boop");
+    ///     }
+    /// }
+    ///
+    /// let mut values = map.get_all("host");
+    /// let mut i = values.iter();
+    /// assert_eq!(&"world-boop", i.next().unwrap());
+    /// assert_eq!(&"earth-boop", i.next().unwrap());
+    /// ```
+    pub fn iter_mut(&mut self) -> ValueIterMut<'_, T> {
+        self.map.value_iter_mut(self.index)
+    }
+}
+
+impl<'a, T> IntoIterator for OccupiedEntry<'a, T> {
+    type Item = &'a mut T;
+    type IntoIter = ValueIterMut<'a, T>;
+
+    fn into_iter(self) -> ValueIterMut<'a, T> {
+        self.map.value_iter_mut(self.index)
+    }
+}
+
+impl<'a, 'b: 'a, T> IntoIterator for &'b OccupiedEntry<'a, T> {
+    type Item = &'a T;
+    type IntoIter = ValueIter<'a, T>;
+
+    fn into_iter(self) -> ValueIter<'a, T> {
+        self.iter()
+    }
+}
+
+impl<'a, 'b: 'a, T> IntoIterator for &'b mut OccupiedEntry<'a, T> {
+    type Item = &'a mut T;
+    type IntoIter = ValueIterMut<'a, T>;
+
+    fn into_iter(self) -> ValueIterMut<'a, T> {
+        self.iter_mut()
+    }
+}
+
+// ===== impl ValueDrain =====
+
+impl<'a, T> Iterator for ValueDrain<'a, T> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        if self.first.is_some() {
+            self.first.take()
+        } else if let Some(ref mut extras) = self.next {
+            extras.next()
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match (&self.first, &self.next) {
+            // Exactly 1
+            (&Some(_), &None) => (1, Some(1)),
+            // 1 + extras
+            (&Some(_), &Some(ref extras)) => {
+                let (l, u) = extras.size_hint();
+                (l + 1, u.map(|u| u + 1))
+            },
+            // Extras only
+            (&None, &Some(ref extras)) => extras.size_hint(),
+            // No more
+            (&None, &None) => (0, Some(0)),
+        }
+    }
+}
+
+impl<'a, T> FusedIterator for ValueDrain<'a, T> {}
+
+impl<'a, T> Drop for ValueDrain<'a, T> {
+    fn drop(&mut self) {
+        while let Some(_) = self.next() {}
+    }
+}
+
+unsafe impl<'a, T: Sync> Sync for ValueDrain<'a, T> {}
+unsafe impl<'a, T: Send> Send for ValueDrain<'a, T> {}
+
+// ===== impl RawLinks =====
+
+impl<T> Clone for RawLinks<T> {
+    fn clone(&self) -> RawLinks<T> {
+        *self
+    }
+}
+
+impl<T> Copy for RawLinks<T> {}
+
+impl<T> ops::Index<usize> for RawLinks<T> {
+    type Output = Option<Links>;
+
+    fn index(&self, idx: usize) -> &Self::Output {
+        unsafe {
+            &(*self.0)[idx].links
+        }
+    }
+}
+
+impl<T> ops::IndexMut<usize> for RawLinks<T> {
+    fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
+        unsafe {
+            &mut (*self.0)[idx].links
+        }
+    }
+}
+
+// ===== impl Pos =====
+
+impl Pos {
+    #[inline]
+    fn new(index: usize, hash: HashValue) -> Self {
+        debug_assert!(index < MAX_SIZE);
+        Pos {
+            index: index as Size,
+            hash: hash,
+        }
+    }
+
+    #[inline]
+    fn none() -> Self {
+        Pos {
+            index: !0,
+            hash: HashValue(0),
+        }
+    }
+
+    #[inline]
+    fn is_some(&self) -> bool {
+        !self.is_none()
+    }
+
+    #[inline]
+    fn is_none(&self) -> bool {
+        self.index == !0
+    }
+
+    #[inline]
+    fn resolve(&self) -> Option<(usize, HashValue)> {
+        if self.is_some() {
+            Some((self.index as usize, self.hash))
+        } else {
+            None
+        }
+    }
+}
+
+impl Danger {
+    fn is_red(&self) -> bool {
+        match *self {
+            Danger::Red(_) => true,
+            _ => false,
+        }
+    }
+
+    fn to_red(&mut self) {
+        debug_assert!(self.is_yellow());
+        *self = Danger::Red(RandomState::new());
+    }
+
+    fn is_yellow(&self) -> bool {
+        match *self {
+            Danger::Yellow => true,
+            _ => false,
+        }
+    }
+
+    fn to_yellow(&mut self) {
+        match *self {
+            Danger::Green => {
+                *self = Danger::Yellow;
+            }
+            _ => {}
+        }
+    }
+
+    fn to_green(&mut self) {
+        debug_assert!(self.is_yellow());
+        *self = Danger::Green;
+    }
+}
+
+// ===== impl Utils =====
+
+#[inline]
+fn usable_capacity(cap: usize) -> usize {
+    cap - cap / 4
+}
+
+#[inline]
+fn to_raw_capacity(n: usize) -> usize {
+    n + n / 3
+}
+
+#[inline]
+fn desired_pos(mask: Size, hash: HashValue) -> usize {
+    (hash.0 & mask) as usize
+}
+
+/// The number of steps that `current` is forward of the desired position for hash
+#[inline]
+fn probe_distance(mask: Size, hash: HashValue, current: usize) -> usize {
+    current.wrapping_sub(desired_pos(mask, hash)) & mask as usize
+}
+
+fn hash_elem_using<K: ?Sized>(danger: &Danger, k: &K) -> HashValue
+where
+    K: Hash,
+{
+    use fnv::FnvHasher;
+
+    const MASK: u64 = (MAX_SIZE as u64) - 1;
+
+    let hash = match *danger {
+        // Safe hash
+        Danger::Red(ref hasher) => {
+            let mut h = hasher.build_hasher();
+            k.hash(&mut h);
+            h.finish()
+        }
+        // Fast hash
+        _ => {
+            let mut h = FnvHasher::default();
+            k.hash(&mut h);
+            h.finish()
+        }
+    };
+
+    HashValue((hash & MASK) as u16)
+}
+
+/*
+ *
+ * ===== impl IntoHeaderName / AsHeaderName =====
+ *
+ */
+
+mod into_header_name {
+    use super::{Entry, HdrName, HeaderMap, HeaderName};
+
+    /// A marker trait used to identify values that can be used as insert keys
+    /// to a `HeaderMap`.
+    pub trait IntoHeaderName: Sealed {}
+
+    // All methods are on this pub(super) trait, instead of `IntoHeaderName`,
+    // so that they aren't publicly exposed to the world.
+    //
+    // Being on the `IntoHeaderName` trait would mean users could call
+    // `"host".insert(&mut map, "localhost")`.
+    //
+    // Ultimately, this allows us to adjust the signatures of these methods
+    // without breaking any external crate.
+    pub trait Sealed {
+        #[doc(hidden)]
+        fn insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Option<T>;
+
+        #[doc(hidden)]
+        fn append<T>(self, map: &mut HeaderMap<T>, val: T) -> bool;
+
+        #[doc(hidden)]
+        fn entry<T>(self, map: &mut HeaderMap<T>) -> Entry<'_, T>;
+    }
+
+    // ==== impls ====
+
+    impl Sealed for HeaderName {
+        #[inline]
+        fn insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Option<T> {
+            map.insert2(self, val)
+        }
+
+        #[inline]
+        fn append<T>(self, map: &mut HeaderMap<T>, val: T) -> bool {
+            map.append2(self, val)
+        }
+
+        #[inline]
+        fn entry<T>(self, map: &mut HeaderMap<T>) -> Entry<'_, T> {
+            map.entry2(self)
+        }
+    }
+
+    impl IntoHeaderName for HeaderName {}
+
+    impl<'a> Sealed for &'a HeaderName {
+        #[inline]
+        fn insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Option<T> {
+            map.insert2(self, val)
+        }
+        #[inline]
+        fn append<T>(self, map: &mut HeaderMap<T>, val: T) -> bool {
+            map.append2(self, val)
+        }
+
+        #[inline]
+        fn entry<T>(self, map: &mut HeaderMap<T>) -> Entry<'_, T> {
+            map.entry2(self)
+        }
+    }
+
+    impl<'a> IntoHeaderName for &'a HeaderName {}
+
+    impl Sealed for &'static str {
+        #[inline]
+        fn insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Option<T> {
+            HdrName::from_static(self, move |hdr| map.insert2(hdr, val))
+        }
+        #[inline]
+        fn append<T>(self, map: &mut HeaderMap<T>, val: T) -> bool {
+            HdrName::from_static(self, move |hdr| map.append2(hdr, val))
+        }
+
+        #[inline]
+        fn entry<T>(self, map: &mut HeaderMap<T>) -> Entry<'_, T> {
+            HdrName::from_static(self, move |hdr| map.entry2(hdr))
+        }
+    }
+
+    impl IntoHeaderName for &'static str {}
+}
+
+mod as_header_name {
+    use super::{Entry, HdrName, HeaderMap, HeaderName, InvalidHeaderName};
+
+    /// A marker trait used to identify values that can be used as search keys
+    /// to a `HeaderMap`.
+    pub trait AsHeaderName: Sealed {}
+
+    // All methods are on this pub(super) trait, instead of `AsHeaderName`,
+    // so that they aren't publicly exposed to the world.
+    //
+    // Being on the `AsHeaderName` trait would mean users could call
+    // `"host".find(&map)`.
+    //
+    // Ultimately, this allows us to adjust the signatures of these methods
+    // without breaking any external crate.
+    pub trait Sealed {
+        #[doc(hidden)]
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, InvalidHeaderName>;
+
+        #[doc(hidden)]
+        fn find<T>(&self, map: &HeaderMap<T>) -> Option<(usize, usize)>;
+
+        #[doc(hidden)]
+        fn as_str(&self) -> &str;
+    }
+
+    // ==== impls ====
+
+    impl Sealed for HeaderName {
+        #[inline]
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, InvalidHeaderName> {
+            Ok(map.entry2(self))
+        }
+
+        #[inline]
+        fn find<T>(&self, map: &HeaderMap<T>) -> Option<(usize, usize)> {
+            map.find(self)
+        }
+
+        fn as_str(&self) -> &str {
+            <HeaderName>::as_str(self)
+        }
+    }
+
+    impl AsHeaderName for HeaderName {}
+
+    impl<'a> Sealed for &'a HeaderName {
+        #[inline]
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, InvalidHeaderName> {
+            Ok(map.entry2(self))
+        }
+
+        #[inline]
+        fn find<T>(&self, map: &HeaderMap<T>) -> Option<(usize, usize)> {
+            map.find(*self)
+        }
+
+        fn as_str(&self) -> &str {
+            <HeaderName>::as_str(*self)
+        }
+    }
+
+    impl<'a> AsHeaderName for &'a HeaderName {}
+
+    impl<'a> Sealed for &'a str {
+        #[inline]
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, InvalidHeaderName> {
+            HdrName::from_bytes(self.as_bytes(), move |hdr| map.entry2(hdr))
+        }
+
+        #[inline]
+        fn find<T>(&self, map: &HeaderMap<T>) -> Option<(usize, usize)> {
+            HdrName::from_bytes(self.as_bytes(), move |hdr| map.find(&hdr)).unwrap_or(None)
+        }
+
+        fn as_str(&self) -> &str {
+            self
+        }
+    }
+
+    impl<'a> AsHeaderName for &'a str {}
+
+    impl Sealed for String {
+        #[inline]
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, InvalidHeaderName> {
+            self.as_str().try_entry(map)
+        }
+
+        #[inline]
+        fn find<T>(&self, map: &HeaderMap<T>) -> Option<(usize, usize)> {
+            Sealed::find(&self.as_str(), map)
+        }
+
+        fn as_str(&self) -> &str {
+            self
+        }
+    }
+
+    impl AsHeaderName for String {}
+
+    impl<'a> Sealed for &'a String {
+        #[inline]
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, InvalidHeaderName> {
+            self.as_str().try_entry(map)
+        }
+
+        #[inline]
+        fn find<T>(&self, map: &HeaderMap<T>) -> Option<(usize, usize)> {
+            Sealed::find(*self, map)
+        }
+
+        fn as_str(&self) -> &str {
+            *self
+        }
+    }
+
+    impl<'a> AsHeaderName for &'a String {}
+}
+
+#[test]
+fn test_bounds() {
+    fn check_bounds<T: Send + Send>() {}
+
+    check_bounds::<HeaderMap<()>>();
+    check_bounds::<Iter<'static, ()>>();
+    check_bounds::<IterMut<'static, ()>>();
+    check_bounds::<Keys<'static, ()>>();
+    check_bounds::<Values<'static, ()>>();
+    check_bounds::<ValuesMut<'static, ()>>();
+    check_bounds::<Drain<'static, ()>>();
+    check_bounds::<GetAll<'static, ()>>();
+    check_bounds::<Entry<'static, ()>>();
+    check_bounds::<VacantEntry<'static, ()>>();
+    check_bounds::<OccupiedEntry<'static, ()>>();
+    check_bounds::<ValueIter<'static, ()>>();
+    check_bounds::<ValueIterMut<'static, ()>>();
+    check_bounds::<ValueDrain<'static, ()>>();
+}
+
+#[test]
+fn skip_duplicates_during_key_iteration() {
+    let mut map = HeaderMap::new();
+    map.append("a", HeaderValue::from_static("a"));
+    map.append("a", HeaderValue::from_static("b"));
+    assert_eq!(map.keys().count(), map.keys_len());
+}
diff --git a/third_party/rust/http/src/header/mod.rs b/third_party/rust/http/src/header/mod.rs
new file mode 100644
index 0000000000..1ca4945094
--- /dev/null
+++ b/third_party/rust/http/src/header/mod.rs
@@ -0,0 +1,174 @@
+//! HTTP header types
+//!
+//! The module provides [`HeaderName`], [`HeaderMap`], and a number of types
+//! used for interacting with `HeaderMap`. These types allow representing both
+//! HTTP/1 and HTTP/2 headers.
+//!
+//! # `HeaderName`
+//!
+//! The `HeaderName` type represents both standard header names as well as
+//! custom header names. The type handles the case insensitive nature of header
+//! names and is used as the key portion of `HeaderMap`. Header names are
+//! normalized to lower case. In other words, when creating a `HeaderName` with
+//! a string, even if upper case characters are included, when getting a string
+//! representation of the `HeaderName`, it will be all lower case. This allows
+//! for faster `HeaderMap` comparison operations.
+//!
+//! The internal representation is optimized to efficiently handle the cases
+//! most commonly encountered when working with HTTP. Standard header names are
+//! special cased and are represented internally as an enum. Short custom
+//! headers will be stored directly in the `HeaderName` struct and will not
+//! incur any allocation overhead, however longer strings will require an
+//! allocation for storage.
+//!
+//! ## Limitations
+//!
+//! `HeaderName` has a max length of 32,768 for header names. Attempting to
+//! parse longer names will result in a panic.
+//!
+//! # `HeaderMap`
+//!
+//! `HeaderMap` is a map structure of header names highly optimized for use
+//! cases common with HTTP. It is a [multimap] structure, where each header name
+//! may have multiple associated header values. Given this, some of the APIs
+//! diverge from [`HashMap`].
+//!
+//! ## Overview
+//!
+//! Just like `HashMap` in Rust's stdlib, `HeaderMap` is based on [Robin Hood
+//! hashing]. This algorithm tends to reduce the worst case search times in the
+//! table and enables high load factors without seriously affecting performance.
+//! Internally, keys and values are stored in vectors. As such, each insertion
+//! will not incur allocation overhead. However, once the underlying vector
+//! storage is full, a larger vector must be allocated and all values copied.
+//!
+//! ## Deterministic ordering
+//!
+//! Unlike Rust's `HashMap`, values in `HeaderMap` are deterministically
+//! ordered. Roughly, values are ordered by insertion. This means that a
+//! function that deterministically operates on a header map can rely on the
+//! iteration order to remain consistent across processes and platforms.
+//!
+//! ## Adaptive hashing
+//!
+//! `HeaderMap` uses an adaptive hashing strategy in order to efficiently handle
+//! most common cases. All standard headers have statically computed hash values
+//! which removes the need to perform any hashing of these headers at runtime.
+//! The default hash function emphasizes performance over robustness. However,
+//! `HeaderMap` detects high collision rates and switches to a secure hash
+//! function in those events. The threshold is set such that only denial of
+//! service attacks should trigger it.
+//!
+//! ## Limitations
+//!
+//! `HeaderMap` can store a maximum of 32,768 headers (header name / value
+//! pairs). Attempting to insert more will result in a panic.
+//!
+//! [`HeaderName`]: struct.HeaderName.html
+//! [`HeaderMap`]: struct.HeaderMap.html
+//! [multimap]: https://en.wikipedia.org/wiki/Multimap
+//! [`HashMap`]: https://doc.rust-lang.org/std/collections/struct.HashMap.html
+//! [Robin Hood hashing]: https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing
+
+mod map;
+mod name;
+mod value;
+
+pub use self::map::{
+    AsHeaderName, Drain, Entry, GetAll, HeaderMap, IntoHeaderName, IntoIter, Iter, IterMut, Keys,
+    OccupiedEntry, VacantEntry, ValueDrain, ValueIter, ValueIterMut, Values, ValuesMut,
+};
+pub use self::name::{HeaderName, InvalidHeaderName};
+pub use self::value::{HeaderValue, InvalidHeaderValue, ToStrError};
+
+// Use header name constants
+pub use self::name::{
+    ACCEPT,
+    ACCEPT_CHARSET,
+    ACCEPT_ENCODING,
+    ACCEPT_LANGUAGE,
+    ACCEPT_RANGES,
+    ACCESS_CONTROL_ALLOW_CREDENTIALS,
+    ACCESS_CONTROL_ALLOW_HEADERS,
+    ACCESS_CONTROL_ALLOW_METHODS,
+    ACCESS_CONTROL_ALLOW_ORIGIN,
+    ACCESS_CONTROL_EXPOSE_HEADERS,
+    ACCESS_CONTROL_MAX_AGE,
+    ACCESS_CONTROL_REQUEST_HEADERS,
+    ACCESS_CONTROL_REQUEST_METHOD,
+    AGE,
+    ALLOW,
+    ALT_SVC,
+    AUTHORIZATION,
+    CACHE_CONTROL,
+    CACHE_STATUS,
+    CDN_CACHE_CONTROL,
+    CONNECTION,
+    CONTENT_DISPOSITION,
+    CONTENT_ENCODING,
+    CONTENT_LANGUAGE,
+    CONTENT_LENGTH,
+    CONTENT_LOCATION,
+    CONTENT_RANGE,
+    CONTENT_SECURITY_POLICY,
+    CONTENT_SECURITY_POLICY_REPORT_ONLY,
+    CONTENT_TYPE,
+    COOKIE,
+    DNT,
+    DATE,
+    ETAG,
+    EXPECT,
+    EXPIRES,
+    FORWARDED,
+    FROM,
+    HOST,
+    IF_MATCH,
+    IF_MODIFIED_SINCE,
+    IF_NONE_MATCH,
+    IF_RANGE,
+    IF_UNMODIFIED_SINCE,
+    LAST_MODIFIED,
+    LINK,
+    LOCATION,
+    MAX_FORWARDS,
+    ORIGIN,
+    PRAGMA,
+    PROXY_AUTHENTICATE,
+    PROXY_AUTHORIZATION,
+    PUBLIC_KEY_PINS,
+    PUBLIC_KEY_PINS_REPORT_ONLY,
+    RANGE,
+    REFERER,
+    REFERRER_POLICY,
+    REFRESH,
+    RETRY_AFTER,
+    SEC_WEBSOCKET_ACCEPT,
+    SEC_WEBSOCKET_EXTENSIONS,
+    SEC_WEBSOCKET_KEY,
+    SEC_WEBSOCKET_PROTOCOL,
+    SEC_WEBSOCKET_VERSION,
+    SERVER,
+    SET_COOKIE,
+    STRICT_TRANSPORT_SECURITY,
+    TE,
+    TRAILER,
+    TRANSFER_ENCODING,
+    UPGRADE,
+    UPGRADE_INSECURE_REQUESTS,
+    USER_AGENT,
+    VARY,
+    VIA,
+    WARNING,
+    WWW_AUTHENTICATE,
+    X_CONTENT_TYPE_OPTIONS,
+    X_DNS_PREFETCH_CONTROL,
+    X_FRAME_OPTIONS,
+    X_XSS_PROTECTION,
+};
+
+/// Maximum length of a header name
+///
+/// Generally, 64kb for a header name is WAY too much than would ever be needed
+/// in practice. Restricting it to this size enables using `u16` values to
+/// represent offsets when dealing with header names.
+const MAX_HEADER_NAME_LEN: usize = (1 << 16) - 1;
diff --git a/third_party/rust/http/src/header/name.rs b/third_party/rust/http/src/header/name.rs
new file mode 100644
index 0000000000..6080cf088b
--- /dev/null
+++ b/third_party/rust/http/src/header/name.rs
@@ -0,0 +1,1868 @@
+use crate::byte_str::ByteStr;
+use bytes::{Bytes, BytesMut};
+
+use std::borrow::Borrow;
+use std::error::Error;
+use std::convert::{TryFrom};
+use std::hash::{Hash, Hasher};
+use std::mem::MaybeUninit;
+use std::str::FromStr;
+use std::fmt;
+
+/// Represents an HTTP header field name
+///
+/// Header field names identify the header. Header sets may include multiple
+/// headers with the same name. The HTTP specification defines a number of
+/// standard headers, but HTTP messages may include non-standard header names as
+/// well as long as they adhere to the specification.
+///
+/// `HeaderName` is used as the [`HeaderMap`] key. Constants are available for
+/// all standard header names in the [`header`] module.
+///
+/// # Representation
+///
+/// `HeaderName` represents standard header names using an `enum`, as such they
+/// will not require an allocation for storage. All custom header names are
+/// lower cased upon conversion to a `HeaderName` value. This avoids the
+/// overhead of dynamically doing lower case conversion during the hash code
+/// computation and the comparison operation.
+///
+/// [`HeaderMap`]: struct.HeaderMap.html
+/// [`header`]: index.html
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct HeaderName {
+    inner: Repr<Custom>,
+}
+
+// Almost a full `HeaderName`
+#[derive(Debug, Hash)]
+pub struct HdrName<'a> {
+    inner: Repr<MaybeLower<'a>>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+enum Repr<T> {
+    Standard(StandardHeader),
+    Custom(T),
+}
+
+// Used to hijack the Hash impl
+#[derive(Debug, Clone, Eq, PartialEq)]
+struct Custom(ByteStr);
+
+#[derive(Debug, Clone)]
+// Invariant: If lower then buf is valid UTF-8.
+struct MaybeLower<'a> {
+    buf: &'a [u8],
+    lower: bool,
+}
+
+/// A possible error when converting a `HeaderName` from another type.
+pub struct InvalidHeaderName {
+    _priv: (),
+}
+
+macro_rules! standard_headers {
+    (
+        $(
+            $(#[$docs:meta])*
+            ($konst:ident, $upcase:ident, $name_bytes:literal);
+        )+
+    ) => {
+        #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+        enum StandardHeader {
+            $(
+                $konst,
+            )+
+        }
+
+        $(
+            $(#[$docs])*
+            pub const $upcase: HeaderName = HeaderName {
+                inner: Repr::Standard(StandardHeader::$konst),
+            };
+        )+
+
+        impl StandardHeader {
+            #[inline]
+            fn as_str(&self) -> &'static str {
+                match *self {
+                    // Safety: test_parse_standard_headers ensures these &[u8]s are &str-safe.
+                    $(
+                    StandardHeader::$konst => unsafe { std::str::from_utf8_unchecked( $name_bytes ) },
+                    )+
+                }
+            }
+
+            const fn from_bytes(name_bytes: &[u8]) -> Option<StandardHeader> {
+                match name_bytes {
+                    $(
+                        $name_bytes => Some(StandardHeader::$konst),
+                    )+
+                    _ => None,
+                }
+            }
+        }
+
+        #[cfg(test)]
+        const TEST_HEADERS: &'static [(StandardHeader, &'static [u8])] = &[
+            $(
+            (StandardHeader::$konst, $name_bytes),
+            )+
+        ];
+
+        #[test]
+        fn test_parse_standard_headers() {
+            for &(std, name_bytes) in TEST_HEADERS {
+                // Test lower case
+                assert_eq!(HeaderName::from_bytes(name_bytes).unwrap(), HeaderName::from(std));
+
+                // Test upper case
+                let upper = std::str::from_utf8(name_bytes).expect("byte string constants are all utf-8").to_uppercase();
+                assert_eq!(HeaderName::from_bytes(upper.as_bytes()).unwrap(), HeaderName::from(std));
+            }
+        }
+
+        #[test]
+        fn test_standard_headers_into_bytes() {
+            for &(std, name_bytes) in TEST_HEADERS {
+                let name = std::str::from_utf8(name_bytes).unwrap();
+                let std = HeaderName::from(std);
+                // Test lower case
+                let bytes: Bytes =
+                    HeaderName::from_bytes(name_bytes).unwrap().inner.into();
+                assert_eq!(bytes, name);
+                assert_eq!(HeaderName::from_bytes(name_bytes).unwrap(), std);
+
+                // Test upper case
+                let upper = name.to_uppercase();
+                let bytes: Bytes =
+                    HeaderName::from_bytes(upper.as_bytes()).unwrap().inner.into();
+                assert_eq!(bytes, name_bytes);
+                assert_eq!(HeaderName::from_bytes(upper.as_bytes()).unwrap(),
+                           std);
+            }
+
+        }
+    }
+}
+
+// Generate constants for all standard HTTP headers. This includes a static hash
+// code for the "fast hash" path. The hash code for static headers *do not* have
+// to match the text representation of those headers. This is because header
+// strings are always converted to the static values (when they match) before
+// being hashed. This means that it is impossible to compare the static hash
+// code of CONTENT_LENGTH with "content-length".
+standard_headers! {
+    /// Advertises which content types the client is able to understand.
+    ///
+    /// The Accept request HTTP header advertises which content types, expressed
+    /// as MIME types, the client is able to understand. Using content
+    /// negotiation, the server then selects one of the proposals, uses it and
+    /// informs the client of its choice with the Content-Type response header.
+    /// Browsers set adequate values for this header depending of the context
+    /// where the request is done: when fetching a CSS stylesheet a different
+    /// value is set for the request than when fetching an image, video or a
+    /// script.
+    (Accept, ACCEPT, b"accept");
+
+    /// Advertises which character set the client is able to understand.
+    ///
+    /// The Accept-Charset request HTTP header advertises which character set
+    /// the client is able to understand. Using content negotiation, the server
+    /// then selects one of the proposals, uses it and informs the client of its
+    /// choice within the Content-Type response header. Browsers usually don't
+    /// set this header as the default value for each content type is usually
+    /// correct and transmitting it would allow easier fingerprinting.
+    ///
+    /// If the server cannot serve any matching character set, it can
+    /// theoretically send back a 406 (Not Acceptable) error code. But, for a
+    /// better user experience, this is rarely done and the more common way is
+    /// to ignore the Accept-Charset header in this case.
+    (AcceptCharset, ACCEPT_CHARSET, b"accept-charset");
+
+    /// Advertises which content encoding the client is able to understand.
+    ///
+    /// The Accept-Encoding request HTTP header advertises which content
+    /// encoding, usually a compression algorithm, the client is able to
+    /// understand. Using content negotiation, the server selects one of the
+    /// proposals, uses it and informs the client of its choice with the
+    /// Content-Encoding response header.
+    ///
+    /// Even if both the client and the server supports the same compression
+    /// algorithms, the server may choose not to compress the body of a
+    /// response, if the identity value is also acceptable. Two common cases
+    /// lead to this:
+    ///
+    /// * The data to be sent is already compressed and a second compression
+    /// won't lead to smaller data to be transmitted. This may the case with
+    /// some image formats;
+    ///
+    /// * The server is overloaded and cannot afford the computational overhead
+    /// induced by the compression requirement. Typically, Microsoft recommends
+    /// not to compress if a server use more than 80 % of its computational
+    /// power.
+    ///
+    /// As long as the identity value, meaning no encryption, is not explicitly
+    /// forbidden, by an identity;q=0 or a *;q=0 without another explicitly set
+    /// value for identity, the server must never send back a 406 Not Acceptable
+    /// error.
+    (AcceptEncoding, ACCEPT_ENCODING, b"accept-encoding");
+
+    /// Advertises which languages the client is able to understand.
+    ///
+    /// The Accept-Language request HTTP header advertises which languages the
+    /// client is able to understand, and which locale variant is preferred.
+    /// Using content negotiation, the server then selects one of the proposals,
+    /// uses it and informs the client of its choice with the Content-Language
+    /// response header. Browsers set adequate values for this header according
+    /// their user interface language and even if a user can change it, this
+    /// happens rarely (and is frown upon as it leads to fingerprinting).
+    ///
+    /// This header is a hint to be used when the server has no way of
+    /// determining the language via another way, like a specific URL, that is
+    /// controlled by an explicit user decision. It is recommended that the
+    /// server never overrides an explicit decision. The content of the
+    /// Accept-Language is often out of the control of the user (like when
+    /// traveling and using an Internet Cafe in a different country); the user
+    /// may also want to visit a page in another language than the locale of
+    /// their user interface.
+    ///
+    /// If the server cannot serve any matching language, it can theoretically
+    /// send back a 406 (Not Acceptable) error code. But, for a better user
+    /// experience, this is rarely done and more common way is to ignore the
+    /// Accept-Language header in this case.
+    (AcceptLanguage, ACCEPT_LANGUAGE, b"accept-language");
+
+    /// Marker used by the server to advertise partial request support.
+    ///
+    /// The Accept-Ranges response HTTP header is a marker used by the server to
+    /// advertise its support of partial requests. The value of this field
+    /// indicates the unit that can be used to define a range.
+    ///
+    /// In presence of an Accept-Ranges header, the browser may try to resume an
+    /// interrupted download, rather than to start it from the start again.
+    (AcceptRanges, ACCEPT_RANGES, b"accept-ranges");
+
+    /// Preflight response indicating if the response to the request can be
+    /// exposed to the page.
+    ///
+    /// The Access-Control-Allow-Credentials response header indicates whether
+    /// or not the response to the request can be exposed to the page. It can be
+    /// exposed when the true value is returned; it can't in other cases.
+    ///
+    /// Credentials are cookies, authorization headers or TLS client
+    /// certificates.
+    ///
+    /// When used as part of a response to a preflight request, this indicates
+    /// whether or not the actual request can be made using credentials. Note
+    /// that simple GET requests are not preflighted, and so if a request is
+    /// made for a resource with credentials, if this header is not returned
+    /// with the resource, the response is ignored by the browser and not
+    /// returned to web content.
+    ///
+    /// The Access-Control-Allow-Credentials header works in conjunction with
+    /// the XMLHttpRequest.withCredentials property or with the credentials
+    /// option in the Request() constructor of the Fetch API. Credentials must
+    /// be set on both sides (the Access-Control-Allow-Credentials header and in
+    /// the XHR or Fetch request) in order for the CORS request with credentials
+    /// to succeed.
+    (AccessControlAllowCredentials, ACCESS_CONTROL_ALLOW_CREDENTIALS, b"access-control-allow-credentials");
+
+    /// Preflight response indicating permitted HTTP headers.
+    ///
+    /// The Access-Control-Allow-Headers response header is used in response to
+    /// a preflight request to indicate which HTTP headers will be available via
+    /// Access-Control-Expose-Headers when making the actual request.
+    ///
+    /// The simple headers, Accept, Accept-Language, Content-Language,
+    /// Content-Type (but only with a MIME type of its parsed value (ignoring
+    /// parameters) of either application/x-www-form-urlencoded,
+    /// multipart/form-data, or text/plain), are always available and don't need
+    /// to be listed by this header.
+    ///
+    /// This header is required if the request has an
+    /// Access-Control-Request-Headers header.
+    (AccessControlAllowHeaders, ACCESS_CONTROL_ALLOW_HEADERS, b"access-control-allow-headers");
+
+    /// Preflight header response indicating permitted access methods.
+    ///
+    /// The Access-Control-Allow-Methods response header specifies the method or
+    /// methods allowed when accessing the resource in response to a preflight
+    /// request.
+    (AccessControlAllowMethods, ACCESS_CONTROL_ALLOW_METHODS, b"access-control-allow-methods");
+
+    /// Indicates whether the response can be shared with resources with the
+    /// given origin.
+    (AccessControlAllowOrigin, ACCESS_CONTROL_ALLOW_ORIGIN, b"access-control-allow-origin");
+
+    /// Indicates which headers can be exposed as part of the response by
+    /// listing their names.
+    (AccessControlExposeHeaders, ACCESS_CONTROL_EXPOSE_HEADERS, b"access-control-expose-headers");
+
+    /// Indicates how long the results of a preflight request can be cached.
+    (AccessControlMaxAge, ACCESS_CONTROL_MAX_AGE, b"access-control-max-age");
+
+    /// Informs the server which HTTP headers will be used when an actual
+    /// request is made.
+    (AccessControlRequestHeaders, ACCESS_CONTROL_REQUEST_HEADERS, b"access-control-request-headers");
+
+    /// Informs the server know which HTTP method will be used when the actual
+    /// request is made.
+    (AccessControlRequestMethod, ACCESS_CONTROL_REQUEST_METHOD, b"access-control-request-method");
+
+    /// Indicates the time in seconds the object has been in a proxy cache.
+    ///
+    /// The Age header is usually close to zero. If it is Age: 0, it was
+    /// probably just fetched from the origin server; otherwise It is usually
+    /// calculated as a difference between the proxy's current date and the Date
+    /// general header included in the HTTP response.
+    (Age, AGE, b"age");
+
+    /// Lists the set of methods support by a resource.
+    ///
+    /// This header must be sent if the server responds with a 405 Method Not
+    /// Allowed status code to indicate which request methods can be used. An
+    /// empty Allow header indicates that the resource allows no request
+    /// methods, which might occur temporarily for a given resource, for
+    /// example.
+    (Allow, ALLOW, b"allow");
+
+    /// Advertises the availability of alternate services to clients.
+    (AltSvc, ALT_SVC, b"alt-svc");
+
+    /// Contains the credentials to authenticate a user agent with a server.
+    ///
+    /// Usually this header is included after the server has responded with a
+    /// 401 Unauthorized status and the WWW-Authenticate header.
+    (Authorization, AUTHORIZATION, b"authorization");
+
+    /// Specifies directives for caching mechanisms in both requests and
+    /// responses.
+    ///
+    /// Caching directives are unidirectional, meaning that a given directive in
+    /// a request is not implying that the same directive is to be given in the
+    /// response.
+    (CacheControl, CACHE_CONTROL, b"cache-control");
+
+    /// Indicates how caches have handled a response and its corresponding request.
+    ///
+    /// See [RFC 9211](https://www.rfc-editor.org/rfc/rfc9211.html).
+    (CacheStatus, CACHE_STATUS, b"cache-status");
+
+    /// Specifies directives that allow origin servers to control the behavior of CDN caches
+    /// interposed between them and clients separately from other caches that might handle the
+    /// response.
+    ///
+    /// See [RFC 9213](https://www.rfc-editor.org/rfc/rfc9213.html).
+    (CdnCacheControl, CDN_CACHE_CONTROL, b"cdn-cache-control");
+
+    /// Controls whether or not the network connection stays open after the
+    /// current transaction finishes.
+    ///
+    /// If the value sent is keep-alive, the connection is persistent and not
+    /// closed, allowing for subsequent requests to the same server to be done.
+    ///
+    /// Except for the standard hop-by-hop headers (Keep-Alive,
+    /// Transfer-Encoding, TE, Connection, Trailer, Upgrade, Proxy-Authorization
+    /// and Proxy-Authenticate), any hop-by-hop headers used by the message must
+    /// be listed in the Connection header, so that the first proxy knows he has
+    /// to consume them and not to forward them further. Standard hop-by-hop
+    /// headers can be listed too (it is often the case of Keep-Alive, but this
+    /// is not mandatory.
+    (Connection, CONNECTION, b"connection");
+
+    /// Indicates if the content is expected to be displayed inline.
+    ///
+    /// In a regular HTTP response, the Content-Disposition response header is a
+    /// header indicating if the content is expected to be displayed inline in
+    /// the browser, that is, as a Web page or as part of a Web page, or as an
+    /// attachment, that is downloaded and saved locally.
+    ///
+    /// In a multipart/form-data body, the HTTP Content-Disposition general
+    /// header is a header that can be used on the subpart of a multipart body
+    /// to give information about the field it applies to. The subpart is
+    /// delimited by the boundary defined in the Content-Type header. Used on
+    /// the body itself, Content-Disposition has no effect.
+    ///
+    /// The Content-Disposition header is defined in the larger context of MIME
+    /// messages for e-mail, but only a subset of the possible parameters apply
+    /// to HTTP forms and POST requests. Only the value form-data, as well as
+    /// the optional directive name and filename, can be used in the HTTP
+    /// context.
+    (ContentDisposition, CONTENT_DISPOSITION, b"content-disposition");
+
+    /// Used to compress the media-type.
+    ///
+    /// When present, its value indicates what additional content encoding has
+    /// been applied to the entity-body. It lets the client know, how to decode
+    /// in order to obtain the media-type referenced by the Content-Type header.
+    ///
+    /// It is recommended to compress data as much as possible and therefore to
+    /// use this field, but some types of resources, like jpeg images, are
+    /// already compressed.  Sometimes using additional compression doesn't
+    /// reduce payload size and can even make the payload longer.
+    (ContentEncoding, CONTENT_ENCODING, b"content-encoding");
+
+    /// Used to describe the languages intended for the audience.
+    ///
+    /// This header allows a user to differentiate according to the users' own
+    /// preferred language. For example, if "Content-Language: de-DE" is set, it
+    /// says that the document is intended for German language speakers
+    /// (however, it doesn't indicate the document is written in German. For
+    /// example, it might be written in English as part of a language course for
+    /// German speakers).
+    ///
+    /// If no Content-Language is specified, the default is that the content is
+    /// intended for all language audiences. Multiple language tags are also
+    /// possible, as well as applying the Content-Language header to various
+    /// media types and not only to textual documents.
+    (ContentLanguage, CONTENT_LANGUAGE, b"content-language");
+
+    /// Indicates the size of the entity-body.
+    ///
+    /// The header value must be a decimal indicating the number of octets sent
+    /// to the recipient.
+    (ContentLength, CONTENT_LENGTH, b"content-length");
+
+    /// Indicates an alternate location for the returned data.
+    ///
+    /// The principal use case is to indicate the URL of the resource
+    /// transmitted as the result of content negotiation.
+    ///
+    /// Location and Content-Location are different: Location indicates the
+    /// target of a redirection (or the URL of a newly created document), while
+    /// Content-Location indicates the direct URL to use to access the resource,
+    /// without the need of further content negotiation. Location is a header
+    /// associated with the response, while Content-Location is associated with
+    /// the entity returned.
+    (ContentLocation, CONTENT_LOCATION, b"content-location");
+
+    /// Indicates where in a full body message a partial message belongs.
+    (ContentRange, CONTENT_RANGE, b"content-range");
+
+    /// Allows controlling resources the user agent is allowed to load for a
+    /// given page.
+    ///
+    /// With a few exceptions, policies mostly involve specifying server origins
+    /// and script endpoints. This helps guard against cross-site scripting
+    /// attacks (XSS).
+    (ContentSecurityPolicy, CONTENT_SECURITY_POLICY, b"content-security-policy");
+
+    /// Allows experimenting with policies by monitoring their effects.
+    ///
+    /// The HTTP Content-Security-Policy-Report-Only response header allows web
+    /// developers to experiment with policies by monitoring (but not enforcing)
+    /// their effects. These violation reports consist of JSON documents sent
+    /// via an HTTP POST request to the specified URI.
+    (ContentSecurityPolicyReportOnly, CONTENT_SECURITY_POLICY_REPORT_ONLY, b"content-security-policy-report-only");
+
+    /// Used to indicate the media type of the resource.
+    ///
+    /// In responses, a Content-Type header tells the client what the content
+    /// type of the returned content actually is. Browsers will do MIME sniffing
+    /// in some cases and will not necessarily follow the value of this header;
+    /// to prevent this behavior, the header X-Content-Type-Options can be set
+    /// to nosniff.
+    ///
+    /// In requests, (such as POST or PUT), the client tells the server what
+    /// type of data is actually sent.
+    (ContentType, CONTENT_TYPE, b"content-type");
+
+    /// Contains stored HTTP cookies previously sent by the server with the
+    /// Set-Cookie header.
+    ///
+    /// The Cookie header might be omitted entirely, if the privacy setting of
+    /// the browser are set to block them, for example.
+    (Cookie, COOKIE, b"cookie");
+
+    /// Indicates the client's tracking preference.
+    ///
+    /// This header lets users indicate whether they would prefer privacy rather
+    /// than personalized content.
+    (Dnt, DNT, b"dnt");
+
+    /// Contains the date and time at which the message was originated.
+    (Date, DATE, b"date");
+
+    /// Identifier for a specific version of a resource.
+    ///
+    /// This header allows caches to be more efficient, and saves bandwidth, as
+    /// a web server does not need to send a full response if the content has
+    /// not changed. On the other side, if the content has changed, etags are
+    /// useful to help prevent simultaneous updates of a resource from
+    /// overwriting each other ("mid-air collisions").
+    ///
+    /// If the resource at a given URL changes, a new Etag value must be
+    /// generated. Etags are therefore similar to fingerprints and might also be
+    /// used for tracking purposes by some servers. A comparison of them allows
+    /// to quickly determine whether two representations of a resource are the
+    /// same, but they might also be set to persist indefinitely by a tracking
+    /// server.
+    (Etag, ETAG, b"etag");
+
+    /// Indicates expectations that need to be fulfilled by the server in order
+    /// to properly handle the request.
+    ///
+    /// The only expectation defined in the specification is Expect:
+    /// 100-continue, to which the server shall respond with:
+    ///
+    /// * 100 if the information contained in the header is sufficient to cause
+    /// an immediate success,
+    ///
+    /// * 417 (Expectation Failed) if it cannot meet the expectation; or any
+    /// other 4xx status otherwise.
+    ///
+    /// For example, the server may reject a request if its Content-Length is
+    /// too large.
+    ///
+    /// No common browsers send the Expect header, but some other clients such
+    /// as cURL do so by default.
+    (Expect, EXPECT, b"expect");
+
+    /// Contains the date/time after which the response is considered stale.
+    ///
+    /// Invalid dates, like the value 0, represent a date in the past and mean
+    /// that the resource is already expired.
+    ///
+    /// If there is a Cache-Control header with the "max-age" or "s-max-age"
+    /// directive in the response, the Expires header is ignored.
+    (Expires, EXPIRES, b"expires");
+
+    /// Contains information from the client-facing side of proxy servers that
+    /// is altered or lost when a proxy is involved in the path of the request.
+    ///
+    /// The alternative and de-facto standard versions of this header are the
+    /// X-Forwarded-For, X-Forwarded-Host and X-Forwarded-Proto headers.
+    ///
+    /// This header is used for debugging, statistics, and generating
+    /// location-dependent content and by design it exposes privacy sensitive
+    /// information, such as the IP address of the client. Therefore the user's
+    /// privacy must be kept in mind when deploying this header.
+    (Forwarded, FORWARDED, b"forwarded");
+
+    /// Contains an Internet email address for a human user who controls the
+    /// requesting user agent.
+    ///
+    /// If you are running a robotic user agent (e.g. a crawler), the From
+    /// header should be sent, so you can be contacted if problems occur on
+    /// servers, such as if the robot is sending excessive, unwanted, or invalid
+    /// requests.
+    (From, FROM, b"from");
+
+    /// Specifies the domain name of the server and (optionally) the TCP port
+    /// number on which the server is listening.
+    ///
+    /// If no port is given, the default port for the service requested (e.g.,
+    /// "80" for an HTTP URL) is implied.
+    ///
+    /// A Host header field must be sent in all HTTP/1.1 request messages. A 400
+    /// (Bad Request) status code will be sent to any HTTP/1.1 request message
+    /// that lacks a Host header field or contains more than one.
+    (Host, HOST, b"host");
+
+    /// Makes a request conditional based on the E-Tag.
+    ///
+    /// For GET and HEAD methods, the server will send back the requested
+    /// resource only if it matches one of the listed ETags. For PUT and other
+    /// non-safe methods, it will only upload the resource in this case.
+    ///
+    /// The comparison with the stored ETag uses the strong comparison
+    /// algorithm, meaning two files are considered identical byte to byte only.
+    /// This is weakened when the  W/ prefix is used in front of the ETag.
+    ///
+    /// There are two common use cases:
+    ///
+    /// * For GET and HEAD methods, used in combination with an Range header, it
+    /// can guarantee that the new ranges requested comes from the same resource
+    /// than the previous one. If it doesn't match, then a 416 (Range Not
+    /// Satisfiable) response is returned.
+    ///
+    /// * For other methods, and in particular for PUT, If-Match can be used to
+    /// prevent the lost update problem. It can check if the modification of a
+    /// resource that the user wants to upload will not override another change
+    /// that has been done since the original resource was fetched. If the
+    /// request cannot be fulfilled, the 412 (Precondition Failed) response is
+    /// returned.
+    (IfMatch, IF_MATCH, b"if-match");
+
+    /// Makes a request conditional based on the modification date.
+    ///
+    /// The If-Modified-Since request HTTP header makes the request conditional:
+    /// the server will send back the requested resource, with a 200 status,
+    /// only if it has been last modified after the given date. If the request
+    /// has not been modified since, the response will be a 304 without any
+    /// body; the Last-Modified header will contain the date of last
+    /// modification. Unlike If-Unmodified-Since, If-Modified-Since can only be
+    /// used with a GET or HEAD.
+    ///
+    /// When used in combination with If-None-Match, it is ignored, unless the
+    /// server doesn't support If-None-Match.
+    ///
+    /// The most common use case is to update a cached entity that has no
+    /// associated ETag.
+    (IfModifiedSince, IF_MODIFIED_SINCE, b"if-modified-since");
+
+    /// Makes a request conditional based on the E-Tag.
+    ///
+    /// The If-None-Match HTTP request header makes the request conditional. For
+    /// GET and HEAD methods, the server will send back the requested resource,
+    /// with a 200 status, only if it doesn't have an ETag matching the given
+    /// ones. For other methods, the request will be processed only if the
+    /// eventually existing resource's ETag doesn't match any of the values
+    /// listed.
+    ///
+    /// When the condition fails for GET and HEAD methods, then the server must
+    /// return HTTP status code 304 (Not Modified). For methods that apply
+    /// server-side changes, the status code 412 (Precondition Failed) is used.
+    /// Note that the server generating a 304 response MUST generate any of the
+    /// following header fields that would have been sent in a 200 (OK) response
+    /// to the same request: Cache-Control, Content-Location, Date, ETag,
+    /// Expires, and Vary.
+    ///
+    /// The comparison with the stored ETag uses the weak comparison algorithm,
+    /// meaning two files are considered identical not only if they are
+    /// identical byte to byte, but if the content is equivalent. For example,
+    /// two pages that would differ only by the date of generation in the footer
+    /// would be considered as identical.
+    ///
+    /// When used in combination with If-Modified-Since, it has precedence (if
+    /// the server supports it).
+    ///
+    /// There are two common use cases:
+    ///
+    /// * For `GET` and `HEAD` methods, to update a cached entity that has an associated ETag.
+    /// * For other methods, and in particular for `PUT`, `If-None-Match` used with
+    /// the `*` value can be used to save a file not known to exist,
+    /// guaranteeing that another upload didn't happen before, losing the data
+    /// of the previous put; this problems is the variation of the lost update
+    /// problem.
+    (IfNoneMatch, IF_NONE_MATCH, b"if-none-match");
+
+    /// Makes a request conditional based on range.
+    ///
+    /// The If-Range HTTP request header makes a range request conditional: if
+    /// the condition is fulfilled, the range request will be issued and the
+    /// server sends back a 206 Partial Content answer with the appropriate
+    /// body. If the condition is not fulfilled, the full resource is sent back,
+    /// with a 200 OK status.
+    ///
+    /// This header can be used either with a Last-Modified validator, or with
+    /// an ETag, but not with both.
+    ///
+    /// The most common use case is to resume a download, to guarantee that the
+    /// stored resource has not been modified since the last fragment has been
+    /// received.
+    (IfRange, IF_RANGE, b"if-range");
+
+    /// Makes the request conditional based on the last modification date.
+    ///
+    /// The If-Unmodified-Since request HTTP header makes the request
+    /// conditional: the server will send back the requested resource, or accept
+    /// it in the case of a POST or another non-safe method, only if it has not
+    /// been last modified after the given date. If the request has been
+    /// modified after the given date, the response will be a 412 (Precondition
+    /// Failed) error.
+    ///
+    /// There are two common use cases:
+    ///
+    /// * In conjunction non-safe methods, like POST, it can be used to
+    /// implement an optimistic concurrency control, like done by some wikis:
+    /// editions are rejected if the stored document has been modified since the
+    /// original has been retrieved.
+    ///
+    /// * In conjunction with a range request with a If-Range header, it can be
+    /// used to ensure that the new fragment requested comes from an unmodified
+    /// document.
+    (IfUnmodifiedSince, IF_UNMODIFIED_SINCE, b"if-unmodified-since");
+
+    /// Content-Types that are acceptable for the response.
+    (LastModified, LAST_MODIFIED, b"last-modified");
+
+    /// Allows the server to point an interested client to another resource
+    /// containing metadata about the requested resource.
+    (Link, LINK, b"link");
+
+    /// Indicates the URL to redirect a page to.
+    ///
+    /// The Location response header indicates the URL to redirect a page to. It
+    /// only provides a meaning when served with a 3xx status response.
+    ///
+    /// The HTTP method used to make the new request to fetch the page pointed
+    /// to by Location depends of the original method and of the kind of
+    /// redirection:
+    ///
+    /// * If 303 (See Also) responses always lead to the use of a GET method,
+    /// 307 (Temporary Redirect) and 308 (Permanent Redirect) don't change the
+    /// method used in the original request;
+    ///
+    /// * 301 (Permanent Redirect) and 302 (Found) doesn't change the method
+    /// most of the time, though older user-agents may (so you basically don't
+    /// know).
+    ///
+    /// All responses with one of these status codes send a Location header.
+    ///
+    /// Beside redirect response, messages with 201 (Created) status also
+    /// include the Location header. It indicates the URL to the newly created
+    /// resource.
+    ///
+    /// Location and Content-Location are different: Location indicates the
+    /// target of a redirection (or the URL of a newly created resource), while
+    /// Content-Location indicates the direct URL to use to access the resource
+    /// when content negotiation happened, without the need of further content
+    /// negotiation. Location is a header associated with the response, while
+    /// Content-Location is associated with the entity returned.
+    (Location, LOCATION, b"location");
+
+    /// Indicates the max number of intermediaries the request should be sent
+    /// through.
+    (MaxForwards, MAX_FORWARDS, b"max-forwards");
+
+    /// Indicates where a fetch originates from.
+    ///
+    /// It doesn't include any path information, but only the server name. It is
+    /// sent with CORS requests, as well as with POST requests. It is similar to
+    /// the Referer header, but, unlike this header, it doesn't disclose the
+    /// whole path.
+    (Origin, ORIGIN, b"origin");
+
+    /// HTTP/1.0 header usually used for backwards compatibility.
+    ///
+    /// The Pragma HTTP/1.0 general header is an implementation-specific header
+    /// that may have various effects along the request-response chain. It is
+    /// used for backwards compatibility with HTTP/1.0 caches where the
+    /// Cache-Control HTTP/1.1 header is not yet present.
+    (Pragma, PRAGMA, b"pragma");
+
+    /// Defines the authentication method that should be used to gain access to
+    /// a proxy.
+    ///
+    /// Unlike `www-authenticate`, the `proxy-authenticate` header field applies
+    /// only to the next outbound client on the response chain. This is because
+    /// only the client that chose a given proxy is likely to have the
+    /// credentials necessary for authentication. However, when multiple proxies
+    /// are used within the same administrative domain, such as office and
+    /// regional caching proxies within a large corporate network, it is common
+    /// for credentials to be generated by the user agent and passed through the
+    /// hierarchy until consumed. Hence, in such a configuration, it will appear
+    /// as if Proxy-Authenticate is being forwarded because each proxy will send
+    /// the same challenge set.
+    ///
+    /// The `proxy-authenticate` header is sent along with a `407 Proxy
+    /// Authentication Required`.
+    (ProxyAuthenticate, PROXY_AUTHENTICATE, b"proxy-authenticate");
+
+    /// Contains the credentials to authenticate a user agent to a proxy server.
+    ///
+    /// This header is usually included after the server has responded with a
+    /// 407 Proxy Authentication Required status and the Proxy-Authenticate
+    /// header.
+    (ProxyAuthorization, PROXY_AUTHORIZATION, b"proxy-authorization");
+
+    /// Associates a specific cryptographic public key with a certain server.
+    ///
+    /// This decreases the risk of MITM attacks with forged certificates. If one
+    /// or several keys are pinned and none of them are used by the server, the
+    /// browser will not accept the response as legitimate, and will not display
+    /// it.
+    (PublicKeyPins, PUBLIC_KEY_PINS, b"public-key-pins");
+
+    /// Sends reports of pinning violation to the report-uri specified in the
+    /// header.
+    ///
+    /// Unlike `Public-Key-Pins`, this header still allows browsers to connect
+    /// to the server if the pinning is violated.
+    (PublicKeyPinsReportOnly, PUBLIC_KEY_PINS_REPORT_ONLY, b"public-key-pins-report-only");
+
+    /// Indicates the part of a document that the server should return.
+    ///
+    /// Several parts can be requested with one Range header at once, and the
+    /// server may send back these ranges in a multipart document. If the server
+    /// sends back ranges, it uses the 206 Partial Content for the response. If
+    /// the ranges are invalid, the server returns the 416 Range Not Satisfiable
+    /// error. The server can also ignore the Range header and return the whole
+    /// document with a 200 status code.
+    (Range, RANGE, b"range");
+
+    /// Contains the address of the previous web page from which a link to the
+    /// currently requested page was followed.
+    ///
+    /// The Referer header allows servers to identify where people are visiting
+    /// them from and may use that data for analytics, logging, or optimized
+    /// caching, for example.
+    (Referer, REFERER, b"referer");
+
+    /// Governs which referrer information should be included with requests
+    /// made.
+    (ReferrerPolicy, REFERRER_POLICY, b"referrer-policy");
+
+    /// Informs the web browser that the current page or frame should be
+    /// refreshed.
+    (Refresh, REFRESH, b"refresh");
+
+    /// The Retry-After response HTTP header indicates how long the user agent
+    /// should wait before making a follow-up request. There are two main cases
+    /// this header is used:
+    ///
+    /// * When sent with a 503 (Service Unavailable) response, it indicates how
+    /// long the service is expected to be unavailable.
+    ///
+    /// * When sent with a redirect response, such as 301 (Moved Permanently),
+    /// it indicates the minimum time that the user agent is asked to wait
+    /// before issuing the redirected request.
+    (RetryAfter, RETRY_AFTER, b"retry-after");
+
+    /// The |Sec-WebSocket-Accept| header field is used in the WebSocket
+    /// opening handshake. It is sent from the server to the client to
+    /// confirm that the server is willing to initiate the WebSocket
+    /// connection.
+    (SecWebSocketAccept, SEC_WEBSOCKET_ACCEPT, b"sec-websocket-accept");
+
+    /// The |Sec-WebSocket-Extensions| header field is used in the WebSocket
+    /// opening handshake. It is initially sent from the client to the
+    /// server, and then subsequently sent from the server to the client, to
+    /// agree on a set of protocol-level extensions to use for the duration
+    /// of the connection.
+    (SecWebSocketExtensions, SEC_WEBSOCKET_EXTENSIONS, b"sec-websocket-extensions");
+
+    /// The |Sec-WebSocket-Key| header field is used in the WebSocket opening
+    /// handshake. It is sent from the client to the server to provide part
+    /// of the information used by the server to prove that it received a
+    /// valid WebSocket opening handshake. This helps ensure that the server
+    /// does not accept connections from non-WebSocket clients (e.g., HTTP
+    /// clients) that are being abused to send data to unsuspecting WebSocket
+    /// servers.
+    (SecWebSocketKey, SEC_WEBSOCKET_KEY, b"sec-websocket-key");
+
+    /// The |Sec-WebSocket-Protocol| header field is used in the WebSocket
+    /// opening handshake. It is sent from the client to the server and back
+    /// from the server to the client to confirm the subprotocol of the
+    /// connection.  This enables scripts to both select a subprotocol and be
+    /// sure that the server agreed to serve that subprotocol.
+    (SecWebSocketProtocol, SEC_WEBSOCKET_PROTOCOL, b"sec-websocket-protocol");
+
+    /// The |Sec-WebSocket-Version| header field is used in the WebSocket
+    /// opening handshake.  It is sent from the client to the server to
+    /// indicate the protocol version of the connection.  This enables
+    /// servers to correctly interpret the opening handshake and subsequent
+    /// data being sent from the data, and close the connection if the server
+    /// cannot interpret that data in a safe manner.
+    (SecWebSocketVersion, SEC_WEBSOCKET_VERSION, b"sec-websocket-version");
+
+    /// Contains information about the software used by the origin server to
+    /// handle the request.
+    ///
+    /// Overly long and detailed Server values should be avoided as they
+    /// potentially reveal internal implementation details that might make it
+    /// (slightly) easier for attackers to find and exploit known security
+    /// holes.
+    (Server, SERVER, b"server");
+
+    /// Used to send cookies from the server to the user agent.
+    (SetCookie, SET_COOKIE, b"set-cookie");
+
+    /// Tells the client to communicate with HTTPS instead of using HTTP.
+    (StrictTransportSecurity, STRICT_TRANSPORT_SECURITY, b"strict-transport-security");
+
+    /// Informs the server of transfer encodings willing to be accepted as part
+    /// of the response.
+    ///
+    /// See also the Transfer-Encoding response header for more details on
+    /// transfer encodings. Note that chunked is always acceptable for HTTP/1.1
+    /// recipients and you that don't have to specify "chunked" using the TE
+    /// header. However, it is useful for setting if the client is accepting
+    /// trailer fields in a chunked transfer coding using the "trailers" value.
+    (Te, TE, b"te");
+
+    /// Allows the sender to include additional fields at the end of chunked
+    /// messages.
+    (Trailer, TRAILER, b"trailer");
+
+    /// Specifies the form of encoding used to safely transfer the entity to the
+    /// client.
+    ///
+    /// `transfer-encoding` is a hop-by-hop header, that is applying to a
+    /// message between two nodes, not to a resource itself. Each segment of a
+    /// multi-node connection can use different `transfer-encoding` values. If
+    /// you want to compress data over the whole connection, use the end-to-end
+    /// header `content-encoding` header instead.
+    ///
+    /// When present on a response to a `HEAD` request that has no body, it
+    /// indicates the value that would have applied to the corresponding `GET`
+    /// message.
+    (TransferEncoding, TRANSFER_ENCODING, b"transfer-encoding");
+
+    /// Contains a string that allows identifying the requesting client's
+    /// software.
+    (UserAgent, USER_AGENT, b"user-agent");
+
+    /// Used as part of the exchange to upgrade the protocol.
+    (Upgrade, UPGRADE, b"upgrade");
+
+    /// Sends a signal to the server expressing the client’s preference for an
+    /// encrypted and authenticated response.
+    (UpgradeInsecureRequests, UPGRADE_INSECURE_REQUESTS, b"upgrade-insecure-requests");
+
+    /// Determines how to match future requests with cached responses.
+    ///
+    /// The `vary` HTTP response header determines how to match future request
+    /// headers to decide whether a cached response can be used rather than
+    /// requesting a fresh one from the origin server. It is used by the server
+    /// to indicate which headers it used when selecting a representation of a
+    /// resource in a content negotiation algorithm.
+    ///
+    /// The `vary` header should be set on a 304 Not Modified response exactly
+    /// like it would have been set on an equivalent 200 OK response.
+    (Vary, VARY, b"vary");
+
+    /// Added by proxies to track routing.
+    ///
+    /// The `via` general header is added by proxies, both forward and reverse
+    /// proxies, and can appear in the request headers and the response headers.
+    /// It is used for tracking message forwards, avoiding request loops, and
+    /// identifying the protocol capabilities of senders along the
+    /// request/response chain.
+    (Via, VIA, b"via");
+
+    /// General HTTP header contains information about possible problems with
+    /// the status of the message.
+    ///
+    /// More than one `warning` header may appear in a response. Warning header
+    /// fields can in general be applied to any message, however some warn-codes
+    /// are specific to caches and can only be applied to response messages.
+    (Warning, WARNING, b"warning");
+
+    /// Defines the authentication method that should be used to gain access to
+    /// a resource.
+    (WwwAuthenticate, WWW_AUTHENTICATE, b"www-authenticate");
+
+    /// Marker used by the server to indicate that the MIME types advertised in
+    /// the `content-type` headers should not be changed and be followed.
+    ///
+    /// This allows to opt-out of MIME type sniffing, or, in other words, it is
+    /// a way to say that the webmasters knew what they were doing.
+    ///
+    /// This header was introduced by Microsoft in IE 8 as a way for webmasters
+    /// to block content sniffing that was happening and could transform
+    /// non-executable MIME types into executable MIME types. Since then, other
+    /// browsers have introduced it, even if their MIME sniffing algorithms were
+    /// less aggressive.
+    ///
+    /// Site security testers usually expect this header to be set.
+    (XContentTypeOptions, X_CONTENT_TYPE_OPTIONS, b"x-content-type-options");
+
+    /// Controls DNS prefetching.
+    ///
+    /// The `x-dns-prefetch-control` HTTP response header controls DNS
+    /// prefetching, a feature by which browsers proactively perform domain name
+    /// resolution on both links that the user may choose to follow as well as
+    /// URLs for items referenced by the document, including images, CSS,
+    /// JavaScript, and so forth.
+    ///
+    /// This prefetching is performed in the background, so that the DNS is
+    /// likely to have been resolved by the time the referenced items are
+    /// needed. This reduces latency when the user clicks a link.
+    (XDnsPrefetchControl, X_DNS_PREFETCH_CONTROL, b"x-dns-prefetch-control");
+
+    /// Indicates whether or not a browser should be allowed to render a page in
+    /// a frame.
+    ///
+    /// Sites can use this to avoid clickjacking attacks, by ensuring that their
+    /// content is not embedded into other sites.
+    ///
+    /// The added security is only provided if the user accessing the document
+    /// is using a browser supporting `x-frame-options`.
+    (XFrameOptions, X_FRAME_OPTIONS, b"x-frame-options");
+
+    /// Stop pages from loading when an XSS attack is detected.
+    ///
+    /// The HTTP X-XSS-Protection response header is a feature of Internet
+    /// Explorer, Chrome and Safari that stops pages from loading when they
+    /// detect reflected cross-site scripting (XSS) attacks. Although these
+    /// protections are largely unnecessary in modern browsers when sites
+    /// implement a strong Content-Security-Policy that disables the use of
+    /// inline JavaScript ('unsafe-inline'), they can still provide protections
+    /// for users of older web browsers that don't yet support CSP.
+    (XXssProtection, X_XSS_PROTECTION, b"x-xss-protection");
+}
+
+/// Valid header name characters
+///
+/// ```not_rust
+///       field-name     = token
+///       separators     = "(" | ")" | "<" | ">" | "@"
+///                      | "," | ";" | ":" | "\" | <">
+///                      | "/" | "[" | "]" | "?" | "="
+///                      | "{" | "}" | SP | HT
+///       token          = 1*tchar
+///       tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+///                      / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+///                      / DIGIT / ALPHA
+///                      ; any VCHAR, except delimiters
+/// ```
+// HEADER_CHARS maps every byte that is 128 or larger to 0 so everything that is
+// mapped by HEADER_CHARS, maps to a valid single-byte UTF-8 codepoint.
+const HEADER_CHARS: [u8; 256] = [
+    //  0      1      2      3      4      5      6      7      8      9
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //   x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  1x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  2x
+        0,     0,     0,  b'!',  b'"',  b'#',  b'$',  b'%',  b'&', b'\'', //  3x
+        0,     0,  b'*',  b'+',     0,  b'-',  b'.',     0,  b'0',  b'1', //  4x
+     b'2',  b'3',  b'4',  b'5',  b'6',  b'7',  b'8',  b'9',     0,     0, //  5x
+        0,     0,     0,     0,     0,  b'a',  b'b',  b'c',  b'd',  b'e', //  6x
+     b'f',  b'g',  b'h',  b'i',  b'j',  b'k',  b'l',  b'm',  b'n',  b'o', //  7x
+     b'p',  b'q',  b'r',  b's',  b't',  b'u',  b'v',  b'w',  b'x',  b'y', //  8x
+     b'z',     0,     0,     0,  b'^',  b'_',  b'`',  b'a',  b'b',  b'c', //  9x
+     b'd',  b'e',  b'f',  b'g',  b'h',  b'i',  b'j',  b'k',  b'l',  b'm', // 10x
+     b'n',  b'o',  b'p',  b'q',  b'r',  b's',  b't',  b'u',  b'v',  b'w', // 11x
+     b'x',  b'y',  b'z',     0,  b'|',     0,  b'~',     0,     0,     0, // 12x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 13x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 14x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 15x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 16x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 17x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 18x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 19x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 20x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 21x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 22x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 23x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 24x
+        0,     0,     0,     0,     0,     0                              // 25x
+];
+
+/// Valid header name characters for HTTP/2.0 and HTTP/3.0
+// HEADER_CHARS_H2 maps every byte that is 128 or larger to 0 so everything that is
+// mapped by HEADER_CHARS_H2, maps to a valid single-byte UTF-8 codepoint.
+const HEADER_CHARS_H2: [u8; 256] = [
+    //  0      1      2      3      4      5      6      7      8      9
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //   x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  1x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  2x
+        0,     0,     0,  b'!',  b'"',  b'#',  b'$',  b'%',  b'&', b'\'', //  3x
+        0,     0,  b'*',  b'+',     0,  b'-',  b'.',     0,  b'0',  b'1', //  4x
+     b'2',  b'3',  b'4',  b'5',  b'6',  b'7',  b'8',  b'9',     0,     0, //  5x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  6x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  7x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, //  8x
+        0,     0,     0,     0,  b'^',  b'_',  b'`',  b'a',  b'b',  b'c', //  9x
+     b'd',  b'e',  b'f',  b'g',  b'h',  b'i',  b'j',  b'k',  b'l',  b'm', // 10x
+     b'n',  b'o',  b'p',  b'q',  b'r',  b's',  b't',  b'u',  b'v',  b'w', // 11x
+     b'x',  b'y',  b'z',     0,  b'|',     0,  b'~',     0,     0,     0, // 12x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 13x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 14x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 15x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 16x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 17x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 18x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 19x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 20x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 21x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 22x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 23x
+        0,     0,     0,     0,     0,     0,     0,     0,     0,     0, // 24x
+        0,     0,     0,     0,     0,     0                              // 25x
+];
+
+fn parse_hdr<'a>(
+    data: &'a [u8],
+    b: &'a mut [MaybeUninit<u8>; SCRATCH_BUF_SIZE],
+    table: &[u8; 256],
+) -> Result<HdrName<'a>, InvalidHeaderName> {
+    match data.len() {
+        0 => Err(InvalidHeaderName::new()),
+        len @ 1..=SCRATCH_BUF_SIZE => {
+            // Read from data into the buffer - transforming using `table` as we go
+            data.iter()
+                .zip(b.iter_mut())
+                .for_each(|(index, out)| *out = MaybeUninit::new(table[*index as usize]));
+            // Safety: len bytes of b were just initialized.
+            let name: &'a [u8] = unsafe { slice_assume_init(&b[0..len]) };
+            match StandardHeader::from_bytes(name) {
+                Some(sh) => Ok(sh.into()),
+                None => {
+                    if name.contains(&0) {
+                        Err(InvalidHeaderName::new())
+                    } else {
+                        Ok(HdrName::custom(name, true))
+                    }
+                }
+            }
+        }
+        SCRATCH_BUF_OVERFLOW..=super::MAX_HEADER_NAME_LEN => Ok(HdrName::custom(data, false)),
+        _ => Err(InvalidHeaderName::new()),
+    }
+}
+
+
+
+impl<'a> From<StandardHeader> for HdrName<'a> {
+    fn from(hdr: StandardHeader) -> HdrName<'a> {
+        HdrName { inner: Repr::Standard(hdr) }
+    }
+}
+
+impl HeaderName {
+    /// Converts a slice of bytes to an HTTP header name.
+    ///
+    /// This function normalizes the input.
+    pub fn from_bytes(src: &[u8]) -> Result<HeaderName, InvalidHeaderName> {
+        let mut buf = uninit_u8_array();
+        // Precondition: HEADER_CHARS is a valid table for parse_hdr().
+        match parse_hdr(src, &mut buf, &HEADER_CHARS)?.inner {
+            Repr::Standard(std) => Ok(std.into()),
+            Repr::Custom(MaybeLower { buf, lower: true }) => {
+                let buf = Bytes::copy_from_slice(buf);
+                // Safety: the invariant on MaybeLower ensures buf is valid UTF-8.
+                let val = unsafe { ByteStr::from_utf8_unchecked(buf) };
+                Ok(Custom(val).into())
+            }
+            Repr::Custom(MaybeLower { buf, lower: false }) => {
+                use bytes::{BufMut};
+                let mut dst = BytesMut::with_capacity(buf.len());
+
+                for b in buf.iter() {
+                    // HEADER_CHARS maps all bytes to valid single-byte UTF-8
+                    let b = HEADER_CHARS[*b as usize];
+
+                    if b == 0 {
+                        return Err(InvalidHeaderName::new());
+                    }
+
+                    dst.put_u8(b);
+                }
+
+                // Safety: the loop above maps all bytes in buf to valid single byte
+                // UTF-8 before copying them into dst. This means that dst (and hence
+                // dst.freeze()) is valid UTF-8.
+                let val = unsafe { ByteStr::from_utf8_unchecked(dst.freeze()) };
+
+                Ok(Custom(val).into())
+            }
+        }
+    }
+
+    /// Converts a slice of bytes to an HTTP header name.
+    ///
+    /// This function expects the input to only contain lowercase characters.
+    /// This is useful when decoding HTTP/2.0 or HTTP/3.0 headers. Both
+    /// require that all headers be represented in lower case.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::*;
+    ///
+    /// // Parsing a lower case header
+    /// let hdr = HeaderName::from_lowercase(b"content-length").unwrap();
+    /// assert_eq!(CONTENT_LENGTH, hdr);
+    ///
+    /// // Parsing a header that contains uppercase characters
+    /// assert!(HeaderName::from_lowercase(b"Content-Length").is_err());
+    /// ```
+    pub fn from_lowercase(src: &[u8]) -> Result<HeaderName, InvalidHeaderName> {
+        let mut buf = uninit_u8_array();
+        // Precondition: HEADER_CHARS_H2 is a valid table for parse_hdr()
+        match parse_hdr(src, &mut buf, &HEADER_CHARS_H2)?.inner {
+            Repr::Standard(std) => Ok(std.into()),
+            Repr::Custom(MaybeLower { buf, lower: true }) => {
+                let buf = Bytes::copy_from_slice(buf);
+                // Safety: the invariant on MaybeLower ensures buf is valid UTF-8.
+                let val = unsafe { ByteStr::from_utf8_unchecked(buf) };
+                Ok(Custom(val).into())
+            }
+            Repr::Custom(MaybeLower { buf, lower: false }) => {
+                for &b in buf.iter() {
+                    // HEADER_CHARS maps all bytes that are not valid single-byte
+                    // UTF-8 to 0 so this check returns an error for invalid UTF-8.
+                    if b != HEADER_CHARS[b as usize] {
+                        return Err(InvalidHeaderName::new());
+                    }
+                }
+
+                let buf = Bytes::copy_from_slice(buf);
+                // Safety: the loop above checks that each byte of buf (either
+                // version) is valid UTF-8.
+                let val = unsafe { ByteStr::from_utf8_unchecked(buf) };
+                Ok(Custom(val).into())
+            }
+        }
+    }
+
+    /// Converts a static string to a HTTP header name.
+    ///
+    /// This function requires the static string to only contain lowercase
+    /// characters, numerals and symbols, as per the HTTP/2.0 specification
+    /// and header names internal representation within this library.
+    ///
+    /// # Panics
+    ///
+    /// This function panics when the static string is a invalid header.
+    ///
+    /// Until [Allow panicking in constants](https://github.com/rust-lang/rfcs/pull/2345)
+    /// makes its way into stable, the panic message at compile-time is
+    /// going to look cryptic, but should at least point at your header value:
+    ///
+    /// ```text
+    /// error: any use of this value will cause an error
+    ///     --> http/src/header/name.rs:1241:13
+    ///      |
+    /// 1241 |             ([] as [u8; 0])[0]; // Invalid header name
+    ///      |             ^^^^^^^^^^^^^^^^^^
+    ///      |             |
+    ///      |             index out of bounds: the length is 0 but the index is 0
+    ///      |             inside `http::HeaderName::from_static` at http/src/header/name.rs:1241:13
+    ///      |             inside `INVALID_NAME` at src/main.rs:3:34
+    ///      |
+    ///     ::: src/main.rs:3:1
+    ///      |
+    /// 3    | const INVALID_NAME: HeaderName = HeaderName::from_static("Capitalized");
+    ///      | ------------------------------------------------------------------------
+    /// ```
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::*;
+    /// // Parsing a standard header
+    /// let hdr = HeaderName::from_static("content-length");
+    /// assert_eq!(CONTENT_LENGTH, hdr);
+    ///
+    /// // Parsing a custom header
+    /// let CUSTOM_HEADER: &'static str = "custom-header";
+    ///
+    /// let a = HeaderName::from_lowercase(b"custom-header").unwrap();
+    /// let b = HeaderName::from_static(CUSTOM_HEADER);
+    /// assert_eq!(a, b);
+    /// ```
+    ///
+    /// ```should_panic
+    /// # use http::header::*;
+    /// #
+    /// // Parsing a header that contains invalid symbols(s):
+    /// HeaderName::from_static("content{}{}length"); // This line panics!
+    ///
+    /// // Parsing a header that contains invalid uppercase characters.
+    /// let a = HeaderName::from_static("foobar");
+    /// let b = HeaderName::from_static("FOOBAR"); // This line panics!
+    /// ```
+    #[allow(unconditional_panic)] // required for the panic circumvention
+    pub const fn from_static(src: &'static str) -> HeaderName {
+        let name_bytes = src.as_bytes();
+        if let Some(standard) = StandardHeader::from_bytes(name_bytes) {
+            return HeaderName{
+                inner: Repr::Standard(standard),
+            };
+        }
+
+        if name_bytes.len() == 0 || name_bytes.len() > super::MAX_HEADER_NAME_LEN || {
+            let mut i = 0;
+            loop {
+                if i >= name_bytes.len() {
+                    break false;
+                } else if HEADER_CHARS_H2[name_bytes[i] as usize] == 0 {
+                    break true;
+                }
+                i += 1;
+            }
+        } {
+            ([] as [u8; 0])[0]; // Invalid header name
+        }
+
+        HeaderName {
+            inner: Repr::Custom(Custom(ByteStr::from_static(src)))
+        }
+    }
+
+    /// Returns a `str` representation of the header.
+    ///
+    /// The returned string will always be lower case.
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        match self.inner {
+            Repr::Standard(v) => v.as_str(),
+            Repr::Custom(ref v) => &*v.0,
+        }
+    }
+
+    pub(super) fn into_bytes(self) -> Bytes {
+        self.inner.into()
+    }
+}
+
+impl FromStr for HeaderName {
+    type Err = InvalidHeaderName;
+
+    fn from_str(s: &str) -> Result<HeaderName, InvalidHeaderName> {
+        HeaderName::from_bytes(s.as_bytes()).map_err(|_| InvalidHeaderName { _priv: () })
+    }
+}
+
+impl AsRef<str> for HeaderName {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsRef<[u8]> for HeaderName {
+    fn as_ref(&self) -> &[u8] {
+        self.as_str().as_bytes()
+    }
+}
+
+impl Borrow<str> for HeaderName {
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl fmt::Debug for HeaderName {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self.as_str(), fmt)
+    }
+}
+
+impl fmt::Display for HeaderName {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), fmt)
+    }
+}
+
+impl InvalidHeaderName {
+    fn new() -> InvalidHeaderName {
+        InvalidHeaderName { _priv: () }
+    }
+}
+
+impl<'a> From<&'a HeaderName> for HeaderName {
+    fn from(src: &'a HeaderName) -> HeaderName {
+        src.clone()
+    }
+}
+
+#[doc(hidden)]
+impl<T> From<Repr<T>> for Bytes
+where
+    T: Into<Bytes>,
+{
+    fn from(repr: Repr<T>) -> Bytes {
+        match repr {
+            Repr::Standard(header) => Bytes::from_static(header.as_str().as_bytes()),
+            Repr::Custom(header) => header.into(),
+        }
+    }
+}
+
+impl From<Custom> for Bytes {
+    #[inline]
+    fn from(Custom(inner): Custom) -> Bytes {
+        Bytes::from(inner)
+    }
+}
+
+impl<'a> TryFrom<&'a str> for HeaderName {
+    type Error = InvalidHeaderName;
+    #[inline]
+    fn try_from(s: &'a str) -> Result<Self, Self::Error> {
+        Self::from_bytes(s.as_bytes())
+    }
+}
+
+impl<'a> TryFrom<&'a String> for HeaderName {
+    type Error = InvalidHeaderName;
+    #[inline]
+    fn try_from(s: &'a String) -> Result<Self, Self::Error> {
+        Self::from_bytes(s.as_bytes())
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for HeaderName {
+    type Error = InvalidHeaderName;
+    #[inline]
+    fn try_from(s: &'a [u8]) -> Result<Self, Self::Error> {
+        Self::from_bytes(s)
+    }
+}
+
+impl TryFrom<String> for HeaderName {
+    type Error = InvalidHeaderName;
+
+    #[inline]
+    fn try_from(s: String) -> Result<Self, Self::Error> {
+        Self::from_bytes(s.as_bytes())
+    }
+}
+
+impl TryFrom<Vec<u8>> for HeaderName {
+    type Error = InvalidHeaderName;
+
+    #[inline]
+    fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
+        Self::from_bytes(&vec)
+    }
+}
+
+#[doc(hidden)]
+impl From<StandardHeader> for HeaderName {
+    fn from(src: StandardHeader) -> HeaderName {
+        HeaderName {
+            inner: Repr::Standard(src),
+        }
+    }
+}
+
+#[doc(hidden)]
+impl From<Custom> for HeaderName {
+    fn from(src: Custom) -> HeaderName {
+        HeaderName {
+            inner: Repr::Custom(src),
+        }
+    }
+}
+
+impl<'a> PartialEq<&'a HeaderName> for HeaderName {
+    #[inline]
+    fn eq(&self, other: &&'a HeaderName) -> bool {
+        *self == **other
+    }
+}
+
+impl<'a> PartialEq<HeaderName> for &'a HeaderName {
+    #[inline]
+    fn eq(&self, other: &HeaderName) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialEq<str> for HeaderName {
+    /// Performs a case-insensitive comparison of the string against the header
+    /// name
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use http::header::CONTENT_LENGTH;
+    ///
+    /// assert_eq!(CONTENT_LENGTH, "content-length");
+    /// assert_eq!(CONTENT_LENGTH, "Content-Length");
+    /// assert_ne!(CONTENT_LENGTH, "content length");
+    /// ```
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        eq_ignore_ascii_case(self.as_ref(), other.as_bytes())
+    }
+}
+
+impl PartialEq<HeaderName> for str {
+    /// Performs a case-insensitive comparison of the string against the header
+    /// name
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use http::header::CONTENT_LENGTH;
+    ///
+    /// assert_eq!(CONTENT_LENGTH, "content-length");
+    /// assert_eq!(CONTENT_LENGTH, "Content-Length");
+    /// assert_ne!(CONTENT_LENGTH, "content length");
+    /// ```
+    #[inline]
+    fn eq(&self, other: &HeaderName) -> bool {
+        *other == *self
+    }
+}
+
+impl<'a> PartialEq<&'a str> for HeaderName {
+    /// Performs a case-insensitive comparison of the string against the header
+    /// name
+    #[inline]
+    fn eq(&self, other: &&'a str) -> bool {
+        *self == **other
+    }
+}
+
+impl<'a> PartialEq<HeaderName> for &'a str {
+    /// Performs a case-insensitive comparison of the string against the header
+    /// name
+    #[inline]
+    fn eq(&self, other: &HeaderName) -> bool {
+        *other == *self
+    }
+}
+
+impl fmt::Debug for InvalidHeaderName {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("InvalidHeaderName")
+            // skip _priv noise
+            .finish()
+    }
+}
+
+impl fmt::Display for InvalidHeaderName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("invalid HTTP header name")
+    }
+}
+
+impl Error for InvalidHeaderName {}
+
+// ===== HdrName =====
+
+impl<'a> HdrName<'a> {
+    // Precondition: if lower then buf is valid UTF-8
+    fn custom(buf: &'a [u8], lower: bool) -> HdrName<'a> {
+        HdrName {
+            // Invariant (on MaybeLower): follows from the precondition
+            inner: Repr::Custom(MaybeLower {
+                buf: buf,
+                lower: lower,
+            }),
+        }
+    }
+
+    pub fn from_bytes<F, U>(hdr: &[u8], f: F) -> Result<U, InvalidHeaderName>
+        where F: FnOnce(HdrName<'_>) -> U,
+    {
+        let mut buf = uninit_u8_array();
+        // Precondition: HEADER_CHARS is a valid table for parse_hdr().
+        let hdr = parse_hdr(hdr, &mut buf, &HEADER_CHARS)?;
+        Ok(f(hdr))
+    }
+
+    pub fn from_static<F, U>(hdr: &'static str, f: F) -> U
+    where
+        F: FnOnce(HdrName<'_>) -> U,
+    {
+        let mut buf = uninit_u8_array();
+        let hdr =
+            // Precondition: HEADER_CHARS is a valid table for parse_hdr().
+            parse_hdr(hdr.as_bytes(), &mut buf, &HEADER_CHARS).expect("static str is invalid name");
+        f(hdr)
+    }
+}
+
+#[doc(hidden)]
+impl<'a> From<HdrName<'a>> for HeaderName {
+    fn from(src: HdrName<'a>) -> HeaderName {
+        match src.inner {
+            Repr::Standard(s) => HeaderName {
+                inner: Repr::Standard(s),
+            },
+            Repr::Custom(maybe_lower) => {
+                if maybe_lower.lower {
+                    let buf = Bytes::copy_from_slice(&maybe_lower.buf[..]);
+                    // Safety: the invariant on MaybeLower ensures buf is valid UTF-8.
+                    let byte_str = unsafe { ByteStr::from_utf8_unchecked(buf) };
+
+                    HeaderName {
+                        inner: Repr::Custom(Custom(byte_str)),
+                    }
+                } else {
+                    use bytes::BufMut;
+                    let mut dst = BytesMut::with_capacity(maybe_lower.buf.len());
+
+                    for b in maybe_lower.buf.iter() {
+                        // HEADER_CHARS maps each byte to a valid single-byte UTF-8
+                        // codepoint.
+                        dst.put_u8(HEADER_CHARS[*b as usize]);
+                    }
+
+                    // Safety: the loop above maps each byte of maybe_lower.buf to a
+                    // valid single-byte UTF-8 codepoint before copying it into dst.
+                    // dst (and hence dst.freeze()) is thus valid UTF-8.
+                    let buf = unsafe { ByteStr::from_utf8_unchecked(dst.freeze()) };
+
+                    HeaderName {
+                        inner: Repr::Custom(Custom(buf)),
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[doc(hidden)]
+impl<'a> PartialEq<HdrName<'a>> for HeaderName {
+    #[inline]
+    fn eq(&self, other: &HdrName<'a>) -> bool {
+        match self.inner {
+            Repr::Standard(a) => match other.inner {
+                Repr::Standard(b) => a == b,
+                _ => false,
+            },
+            Repr::Custom(Custom(ref a)) => match other.inner {
+                Repr::Custom(ref b) => {
+                    if b.lower {
+                        a.as_bytes() == b.buf
+                    } else {
+                        eq_ignore_ascii_case(a.as_bytes(), b.buf)
+                    }
+                }
+                _ => false,
+            },
+        }
+    }
+}
+
+// ===== Custom =====
+
+impl Hash for Custom {
+    #[inline]
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        hasher.write(self.0.as_bytes())
+    }
+}
+
+// ===== MaybeLower =====
+
+impl<'a> Hash for MaybeLower<'a> {
+    #[inline]
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        if self.lower {
+            hasher.write(self.buf);
+        } else {
+            for &b in self.buf {
+                hasher.write(&[HEADER_CHARS[b as usize]]);
+            }
+        }
+    }
+}
+
+// Assumes that the left hand side is already lower case
+#[inline]
+fn eq_ignore_ascii_case(lower: &[u8], s: &[u8]) -> bool {
+    if lower.len() != s.len() {
+        return false;
+    }
+
+    lower.iter().zip(s).all(|(a, b)| {
+        *a == HEADER_CHARS[*b as usize]
+    })
+}
+
+// Utility functions for MaybeUninit<>. These are drawn from unstable API's on
+// MaybeUninit<> itself.
+const SCRATCH_BUF_SIZE: usize = 64;
+const SCRATCH_BUF_OVERFLOW: usize = SCRATCH_BUF_SIZE + 1;
+
+fn uninit_u8_array() -> [MaybeUninit<u8>; SCRATCH_BUF_SIZE] {
+    let arr = MaybeUninit::<[MaybeUninit<u8>; SCRATCH_BUF_SIZE]>::uninit();
+    // Safety: assume_init() is claiming that an array of MaybeUninit<>
+    // has been initilized, but MaybeUninit<>'s do not require initilizaton.
+    unsafe { arr.assume_init() }
+}
+
+// Assuming all the elements are initilized, get a slice of them.
+//
+// Safety: All elements of `slice` must be initilized to prevent
+// undefined behavior.
+unsafe fn slice_assume_init<T>(slice: &[MaybeUninit<T>]) -> &[T] {
+    &*(slice as *const [MaybeUninit<T>] as *const [T])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use self::StandardHeader::Vary;
+
+    #[test]
+    fn test_bounds() {
+        fn check_bounds<T: Sync + Send>() {}
+        check_bounds::<HeaderName>();
+    }
+
+    #[test]
+    fn test_parse_invalid_headers() {
+        for i in 0..128 {
+            let hdr = vec![1u8; i];
+            assert!(HeaderName::from_bytes(&hdr).is_err(), "{} invalid header chars did not fail", i);
+        }
+    }
+
+    const ONE_TOO_LONG: &[u8] = &[b'a'; super::super::MAX_HEADER_NAME_LEN+1];
+
+    #[test]
+    fn test_invalid_name_lengths() {
+        assert!(
+            HeaderName::from_bytes(&[]).is_err(),
+            "zero-length header name is an error",
+        );
+
+        let long = &ONE_TOO_LONG[0..super::super::MAX_HEADER_NAME_LEN];
+
+        let long_str = std::str::from_utf8(long).unwrap();
+        assert_eq!(HeaderName::from_static(long_str), long_str); // shouldn't panic!
+
+        assert!(
+            HeaderName::from_bytes(long).is_ok(),
+            "max header name length is ok",
+        );
+        assert!(
+            HeaderName::from_bytes(ONE_TOO_LONG).is_err(),
+            "longer than max header name length is an error",
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_static_invalid_name_lengths() {
+        // Safety: ONE_TOO_LONG contains only the UTF-8 safe, single-byte codepoint b'a'.
+        let _ = HeaderName::from_static(unsafe { std::str::from_utf8_unchecked(ONE_TOO_LONG) });
+    }
+
+    #[test]
+    fn test_from_hdr_name() {
+        use self::StandardHeader::Vary;
+
+        let name = HeaderName::from(HdrName {
+            inner: Repr::Standard(Vary),
+        });
+
+        assert_eq!(name.inner, Repr::Standard(Vary));
+
+        let name = HeaderName::from(HdrName {
+            inner: Repr::Custom(MaybeLower {
+                buf: b"hello-world",
+                lower: true,
+            }),
+        });
+
+        assert_eq!(name.inner, Repr::Custom(Custom(ByteStr::from_static("hello-world"))));
+
+        let name = HeaderName::from(HdrName {
+            inner: Repr::Custom(MaybeLower {
+                buf: b"Hello-World",
+                lower: false,
+            }),
+        });
+
+        assert_eq!(name.inner, Repr::Custom(Custom(ByteStr::from_static("hello-world"))));
+    }
+
+    #[test]
+    fn test_eq_hdr_name() {
+        use self::StandardHeader::Vary;
+
+        let a = HeaderName { inner: Repr::Standard(Vary) };
+        let b = HdrName { inner: Repr::Standard(Vary) };
+
+        assert_eq!(a, b);
+
+        let a = HeaderName { inner: Repr::Custom(Custom(ByteStr::from_static("vaary"))) };
+        assert_ne!(a, b);
+
+        let b = HdrName { inner: Repr::Custom(MaybeLower {
+            buf: b"vaary",
+            lower: true,
+        })};
+
+        assert_eq!(a, b);
+
+        let b = HdrName { inner: Repr::Custom(MaybeLower {
+            buf: b"vaary",
+            lower: false,
+        })};
+
+        assert_eq!(a, b);
+
+        let b = HdrName { inner: Repr::Custom(MaybeLower {
+            buf: b"VAARY",
+            lower: false,
+        })};
+
+        assert_eq!(a, b);
+
+        let a = HeaderName { inner: Repr::Standard(Vary) };
+        assert_ne!(a, b);
+    }
+
+    #[test]
+    fn test_from_static_std() {
+        let a = HeaderName { inner: Repr::Standard(Vary) };
+
+        let b = HeaderName::from_static("vary");
+        assert_eq!(a, b);
+
+        let b = HeaderName::from_static("vaary");
+        assert_ne!(a, b);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_std_uppercase() {
+        HeaderName::from_static("Vary");
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_std_symbol() {
+        HeaderName::from_static("vary{}");
+    }
+
+    // MaybeLower { lower: true }
+    #[test]
+    fn test_from_static_custom_short() {
+        let a = HeaderName { inner: Repr::Custom(Custom(ByteStr::from_static("customheader"))) };
+        let b = HeaderName::from_static("customheader");
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_custom_short_uppercase() {
+        HeaderName::from_static("custom header");
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_custom_short_symbol() {
+        HeaderName::from_static("CustomHeader");
+    }
+
+    // MaybeLower { lower: false }
+    #[test]
+    fn test_from_static_custom_long() {
+        let a = HeaderName { inner: Repr::Custom(Custom(ByteStr::from_static(
+            "longer-than-63--thisheaderislongerthansixtythreecharactersandthushandleddifferent"
+        ))) };
+        let b = HeaderName::from_static(
+            "longer-than-63--thisheaderislongerthansixtythreecharactersandthushandleddifferent"
+        );
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_custom_long_uppercase() {
+        HeaderName::from_static(
+            "Longer-Than-63--ThisHeaderIsLongerThanSixtyThreeCharactersAndThusHandledDifferent"
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_custom_long_symbol() {
+        HeaderName::from_static(
+            "longer-than-63--thisheader{}{}{}{}islongerthansixtythreecharactersandthushandleddifferent"
+        );
+    }
+
+    #[test]
+    fn test_from_static_custom_single_char() {
+        let a = HeaderName { inner: Repr::Custom(Custom(ByteStr::from_static("a"))) };
+        let b = HeaderName::from_static("a");
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_from_static_empty() {
+        HeaderName::from_static("");
+    }
+
+    #[test]
+    fn test_all_tokens() {
+        HeaderName::from_static("!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyz");
+    }
+}
diff --git a/third_party/rust/http/src/header/value.rs b/third_party/rust/http/src/header/value.rs
new file mode 100644
index 0000000000..bf05f16f4e
--- /dev/null
+++ b/third_party/rust/http/src/header/value.rs
@@ -0,0 +1,795 @@
+use bytes::{Bytes, BytesMut};
+
+use std::convert::TryFrom;
+use std::error::Error;
+use std::fmt::Write;
+use std::str::FromStr;
+use std::{cmp, fmt, mem, str};
+
+use crate::header::name::HeaderName;
+
+/// Represents an HTTP header field value.
+///
+/// In practice, HTTP header field values are usually valid ASCII. However, the
+/// HTTP spec allows for a header value to contain opaque bytes as well. In this
+/// case, the header field value is not able to be represented as a string.
+///
+/// To handle this, the `HeaderValue` is useable as a type and can be compared
+/// with strings and implements `Debug`. A `to_str` fn is provided that returns
+/// an `Err` if the header value contains non visible ascii characters.
+#[derive(Clone, Hash)]
+pub struct HeaderValue {
+    inner: Bytes,
+    is_sensitive: bool,
+}
+
+/// A possible error when converting a `HeaderValue` from a string or byte
+/// slice.
+pub struct InvalidHeaderValue {
+    _priv: (),
+}
+
+/// A possible error when converting a `HeaderValue` to a string representation.
+///
+/// Header field values may contain opaque bytes, in which case it is not
+/// possible to represent the value as a string.
+#[derive(Debug)]
+pub struct ToStrError {
+    _priv: (),
+}
+
+impl HeaderValue {
+    /// Convert a static string to a `HeaderValue`.
+    ///
+    /// This function will not perform any copying, however the string is
+    /// checked to ensure that no invalid characters are present. Only visible
+    /// ASCII characters (32-127) are permitted.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the argument contains invalid header value
+    /// characters.
+    ///
+    /// Until [Allow panicking in constants](https://github.com/rust-lang/rfcs/pull/2345)
+    /// makes its way into stable, the panic message at compile-time is
+    /// going to look cryptic, but should at least point at your header value:
+    ///
+    /// ```text
+    /// error: any use of this value will cause an error
+    ///   --> http/src/header/value.rs:67:17
+    ///    |
+    /// 67 |                 ([] as [u8; 0])[0]; // Invalid header value
+    ///    |                 ^^^^^^^^^^^^^^^^^^
+    ///    |                 |
+    ///    |                 index out of bounds: the length is 0 but the index is 0
+    ///    |                 inside `HeaderValue::from_static` at http/src/header/value.rs:67:17
+    ///    |                 inside `INVALID_HEADER` at src/main.rs:73:33
+    ///    |
+    ///   ::: src/main.rs:73:1
+    ///    |
+    /// 73 | const INVALID_HEADER: HeaderValue = HeaderValue::from_static("жsome value");
+    ///    | ----------------------------------------------------------------------------
+    /// ```
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_static("hello");
+    /// assert_eq!(val, "hello");
+    /// ```
+    #[inline]
+    #[allow(unconditional_panic)] // required for the panic circumvention
+    pub const fn from_static(src: &'static str) -> HeaderValue {
+        let bytes = src.as_bytes();
+        let mut i = 0;
+        while i < bytes.len() {
+            if !is_visible_ascii(bytes[i]) {
+                ([] as [u8; 0])[0]; // Invalid header value
+            }
+            i += 1;
+        }
+
+        HeaderValue {
+            inner: Bytes::from_static(bytes),
+            is_sensitive: false,
+        }
+    }
+
+    /// Attempt to convert a string to a `HeaderValue`.
+    ///
+    /// If the argument contains invalid header value characters, an error is
+    /// returned. Only visible ASCII characters (32-127) are permitted. Use
+    /// `from_bytes` to create a `HeaderValue` that includes opaque octets
+    /// (128-255).
+    ///
+    /// This function is intended to be replaced in the future by a `TryFrom`
+    /// implementation once the trait is stabilized in std.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_str("hello").unwrap();
+    /// assert_eq!(val, "hello");
+    /// ```
+    ///
+    /// An invalid value
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_str("\n");
+    /// assert!(val.is_err());
+    /// ```
+    #[inline]
+    pub fn from_str(src: &str) -> Result<HeaderValue, InvalidHeaderValue> {
+        HeaderValue::try_from_generic(src, |s| Bytes::copy_from_slice(s.as_bytes()))
+    }
+
+    /// Converts a HeaderName into a HeaderValue
+    ///
+    /// Since every valid HeaderName is a valid HeaderValue this is done infallibly.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::{HeaderValue, HeaderName};
+    /// # use http::header::ACCEPT;
+    /// let val = HeaderValue::from_name(ACCEPT);
+    /// assert_eq!(val, HeaderValue::from_bytes(b"accept").unwrap());
+    /// ```
+    #[inline]
+    pub fn from_name(name: HeaderName) -> HeaderValue {
+        name.into()
+    }
+
+    /// Attempt to convert a byte slice to a `HeaderValue`.
+    ///
+    /// If the argument contains invalid header value bytes, an error is
+    /// returned. Only byte values between 32 and 255 (inclusive) are permitted,
+    /// excluding byte 127 (DEL).
+    ///
+    /// This function is intended to be replaced in the future by a `TryFrom`
+    /// implementation once the trait is stabilized in std.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_bytes(b"hello\xfa").unwrap();
+    /// assert_eq!(val, &b"hello\xfa"[..]);
+    /// ```
+    ///
+    /// An invalid value
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_bytes(b"\n");
+    /// assert!(val.is_err());
+    /// ```
+    #[inline]
+    pub fn from_bytes(src: &[u8]) -> Result<HeaderValue, InvalidHeaderValue> {
+        HeaderValue::try_from_generic(src, Bytes::copy_from_slice)
+    }
+
+    /// Attempt to convert a `Bytes` buffer to a `HeaderValue`.
+    ///
+    /// This will try to prevent a copy if the type passed is the type used
+    /// internally, and will copy the data if it is not.
+    pub fn from_maybe_shared<T>(src: T) -> Result<HeaderValue, InvalidHeaderValue>
+    where
+        T: AsRef<[u8]> + 'static,
+    {
+        if_downcast_into!(T, Bytes, src, {
+            return HeaderValue::from_shared(src);
+        });
+
+        HeaderValue::from_bytes(src.as_ref())
+    }
+
+    /// Convert a `Bytes` directly into a `HeaderValue` without validating.
+    ///
+    /// This function does NOT validate that illegal bytes are not contained
+    /// within the buffer.
+    pub unsafe fn from_maybe_shared_unchecked<T>(src: T) -> HeaderValue
+    where
+        T: AsRef<[u8]> + 'static,
+    {
+        if cfg!(debug_assertions) {
+            match HeaderValue::from_maybe_shared(src) {
+                Ok(val) => val,
+                Err(_err) => {
+                    panic!("HeaderValue::from_maybe_shared_unchecked() with invalid bytes");
+                }
+            }
+        } else {
+
+            if_downcast_into!(T, Bytes, src, {
+                return HeaderValue {
+                    inner: src,
+                    is_sensitive: false,
+                };
+            });
+
+            let src = Bytes::copy_from_slice(src.as_ref());
+            HeaderValue {
+                inner: src,
+                is_sensitive: false,
+            }
+        }
+    }
+
+    fn from_shared(src: Bytes) -> Result<HeaderValue, InvalidHeaderValue> {
+        HeaderValue::try_from_generic(src, std::convert::identity)
+    }
+
+    fn try_from_generic<T: AsRef<[u8]>, F: FnOnce(T) -> Bytes>(src: T, into: F) -> Result<HeaderValue, InvalidHeaderValue> {
+        for &b in src.as_ref() {
+            if !is_valid(b) {
+                return Err(InvalidHeaderValue { _priv: () });
+            }
+        }
+        Ok(HeaderValue {
+            inner: into(src),
+            is_sensitive: false,
+        })
+    }
+
+    /// Yields a `&str` slice if the `HeaderValue` only contains visible ASCII
+    /// chars.
+    ///
+    /// This function will perform a scan of the header value, checking all the
+    /// characters.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_static("hello");
+    /// assert_eq!(val.to_str().unwrap(), "hello");
+    /// ```
+    pub fn to_str(&self) -> Result<&str, ToStrError> {
+        let bytes = self.as_ref();
+
+        for &b in bytes {
+            if !is_visible_ascii(b) {
+                return Err(ToStrError { _priv: () });
+            }
+        }
+
+        unsafe { Ok(str::from_utf8_unchecked(bytes)) }
+    }
+
+    /// Returns the length of `self`.
+    ///
+    /// This length is in bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_static("hello");
+    /// assert_eq!(val.len(), 5);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.as_ref().len()
+    }
+
+    /// Returns true if the `HeaderValue` has a length of zero bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_static("");
+    /// assert!(val.is_empty());
+    ///
+    /// let val = HeaderValue::from_static("hello");
+    /// assert!(!val.is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Converts a `HeaderValue` to a byte slice.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let val = HeaderValue::from_static("hello");
+    /// assert_eq!(val.as_bytes(), b"hello");
+    /// ```
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8] {
+        self.as_ref()
+    }
+
+    /// Mark that the header value represents sensitive information.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let mut val = HeaderValue::from_static("my secret");
+    ///
+    /// val.set_sensitive(true);
+    /// assert!(val.is_sensitive());
+    ///
+    /// val.set_sensitive(false);
+    /// assert!(!val.is_sensitive());
+    /// ```
+    #[inline]
+    pub fn set_sensitive(&mut self, val: bool) {
+        self.is_sensitive = val;
+    }
+
+    /// Returns `true` if the value represents sensitive data.
+    ///
+    /// Sensitive data could represent passwords or other data that should not
+    /// be stored on disk or in memory. By marking header values as sensitive,
+    /// components using this crate can be instructed to treat them with special
+    /// care for security reasons. For example, caches can avoid storing
+    /// sensitive values, and HPACK encoders used by HTTP/2.0 implementations
+    /// can choose not to compress them.
+    ///
+    /// Additionally, sensitive values will be masked by the `Debug`
+    /// implementation of `HeaderValue`.
+    ///
+    /// Note that sensitivity is not factored into equality or ordering.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use http::header::HeaderValue;
+    /// let mut val = HeaderValue::from_static("my secret");
+    ///
+    /// val.set_sensitive(true);
+    /// assert!(val.is_sensitive());
+    ///
+    /// val.set_sensitive(false);
+    /// assert!(!val.is_sensitive());
+    /// ```
+    #[inline]
+    pub fn is_sensitive(&self) -> bool {
+        self.is_sensitive
+    }
+}
+
+impl AsRef<[u8]> for HeaderValue {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.inner.as_ref()
+    }
+}
+
+impl fmt::Debug for HeaderValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.is_sensitive {
+            f.write_str("Sensitive")
+        } else {
+            f.write_str("\"")?;
+            let mut from = 0;
+            let bytes = self.as_bytes();
+            for (i, &b) in bytes.iter().enumerate() {
+                if !is_visible_ascii(b) || b == b'"' {
+                    if from != i {
+                        f.write_str(unsafe { str::from_utf8_unchecked(&bytes[from..i]) })?;
+                    }
+                    if b == b'"' {
+                        f.write_str("\\\"")?;
+                    } else {
+                        write!(f, "\\x{:x}", b)?;
+                    }
+                    from = i + 1;
+                }
+            }
+
+            f.write_str(unsafe { str::from_utf8_unchecked(&bytes[from..]) })?;
+            f.write_str("\"")
+        }
+    }
+}
+
+impl From<HeaderName> for HeaderValue {
+    #[inline]
+    fn from(h: HeaderName) -> HeaderValue {
+        HeaderValue {
+            inner: h.into_bytes(),
+            is_sensitive: false,
+        }
+    }
+}
+
+macro_rules! from_integers {
+    ($($name:ident: $t:ident => $max_len:expr),*) => {$(
+        impl From<$t> for HeaderValue {
+            fn from(num: $t) -> HeaderValue {
+                let mut buf = if mem::size_of::<BytesMut>() - 1 < $max_len {
+                    // On 32bit platforms, BytesMut max inline size
+                    // is 15 bytes, but the $max_len could be bigger.
+                    //
+                    // The likelihood of the number *actually* being
+                    // that big is very small, so only allocate
+                    // if the number needs that space.
+                    //
+                    // The largest decimal number in 15 digits:
+                    // It wold be 10.pow(15) - 1, but this is a constant
+                    // version.
+                    if num as u64 > 999_999_999_999_999_999 {
+                        BytesMut::with_capacity($max_len)
+                    } else {
+                        // fits inline...
+                        BytesMut::new()
+                    }
+                } else {
+                    // full value fits inline, so don't allocate!
+                    BytesMut::new()
+                };
+                let _ = buf.write_str(::itoa::Buffer::new().format(num));
+                HeaderValue {
+                    inner: buf.freeze(),
+                    is_sensitive: false,
+                }
+            }
+        }
+
+        #[test]
+        fn $name() {
+            let n: $t = 55;
+            let val = HeaderValue::from(n);
+            assert_eq!(val, &n.to_string());
+
+            let n = ::std::$t::MAX;
+            let val = HeaderValue::from(n);
+            assert_eq!(val, &n.to_string());
+        }
+    )*};
+}
+
+from_integers! {
+    // integer type => maximum decimal length
+
+    // u8 purposely left off... HeaderValue::from(b'3') could be confusing
+    from_u16: u16 => 5,
+    from_i16: i16 => 6,
+    from_u32: u32 => 10,
+    from_i32: i32 => 11,
+    from_u64: u64 => 20,
+    from_i64: i64 => 20
+}
+
+#[cfg(target_pointer_width = "16")]
+from_integers! {
+    from_usize: usize => 5,
+    from_isize: isize => 6
+}
+
+#[cfg(target_pointer_width = "32")]
+from_integers! {
+    from_usize: usize => 10,
+    from_isize: isize => 11
+}
+
+#[cfg(target_pointer_width = "64")]
+from_integers! {
+    from_usize: usize => 20,
+    from_isize: isize => 20
+}
+
+#[cfg(test)]
+mod from_header_name_tests {
+    use super::*;
+    use crate::header::map::HeaderMap;
+    use crate::header::name;
+
+    #[test]
+    fn it_can_insert_header_name_as_header_value() {
+        let mut map = HeaderMap::new();
+        map.insert(name::UPGRADE, name::SEC_WEBSOCKET_PROTOCOL.into());
+        map.insert(
+            name::ACCEPT,
+            name::HeaderName::from_bytes(b"hello-world").unwrap().into(),
+        );
+
+        assert_eq!(
+            map.get(name::UPGRADE).unwrap(),
+            HeaderValue::from_bytes(b"sec-websocket-protocol").unwrap()
+        );
+
+        assert_eq!(
+            map.get(name::ACCEPT).unwrap(),
+            HeaderValue::from_bytes(b"hello-world").unwrap()
+        );
+    }
+}
+
+impl FromStr for HeaderValue {
+    type Err = InvalidHeaderValue;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<HeaderValue, Self::Err> {
+        HeaderValue::from_str(s)
+    }
+}
+
+impl<'a> From<&'a HeaderValue> for HeaderValue {
+    #[inline]
+    fn from(t: &'a HeaderValue) -> Self {
+        t.clone()
+    }
+}
+
+impl<'a> TryFrom<&'a str> for HeaderValue {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_from(t: &'a str) -> Result<Self, Self::Error> {
+        t.parse()
+    }
+}
+
+impl<'a> TryFrom<&'a String> for HeaderValue {
+    type Error = InvalidHeaderValue;
+    #[inline]
+    fn try_from(s: &'a String) -> Result<Self, Self::Error> {
+        Self::from_bytes(s.as_bytes())
+    }
+}
+
+impl<'a> TryFrom<&'a [u8]> for HeaderValue {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_from(t: &'a [u8]) -> Result<Self, Self::Error> {
+        HeaderValue::from_bytes(t)
+    }
+}
+
+impl TryFrom<String> for HeaderValue {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_from(t: String) -> Result<Self, Self::Error> {
+        HeaderValue::from_shared(t.into())
+    }
+}
+
+impl TryFrom<Vec<u8>> for HeaderValue {
+    type Error = InvalidHeaderValue;
+
+    #[inline]
+    fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
+        HeaderValue::from_shared(vec.into())
+    }
+}
+
+#[cfg(test)]
+mod try_from_header_name_tests {
+    use super::*;
+    use crate::header::name;
+
+    #[test]
+    fn it_converts_using_try_from() {
+        assert_eq!(
+            HeaderValue::try_from(name::UPGRADE).unwrap(),
+            HeaderValue::from_bytes(b"upgrade").unwrap()
+        );
+    }
+}
+
+const fn is_visible_ascii(b: u8) -> bool {
+    b >= 32 && b < 127 || b == b'\t'
+}
+
+#[inline]
+fn is_valid(b: u8) -> bool {
+    b >= 32 && b != 127 || b == b'\t'
+}
+
+impl fmt::Debug for InvalidHeaderValue {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("InvalidHeaderValue")
+            // skip _priv noise
+            .finish()
+    }
+}
+
+impl fmt::Display for InvalidHeaderValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("failed to parse header value")
+    }
+}
+
+impl Error for InvalidHeaderValue {}
+
+impl fmt::Display for ToStrError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("failed to convert header to a str")
+    }
+}
+
+impl Error for ToStrError {}
+
+// ===== PartialEq / PartialOrd =====
+
+impl PartialEq for HeaderValue {
+    #[inline]
+    fn eq(&self, other: &HeaderValue) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl Eq for HeaderValue {}
+
+impl PartialOrd for HeaderValue {
+    #[inline]
+    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
+        self.inner.partial_cmp(&other.inner)
+    }
+}
+
+impl Ord for HeaderValue {
+    #[inline]
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.inner.cmp(&other.inner)
+    }
+}
+
+impl PartialEq<str> for HeaderValue {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        self.inner == other.as_bytes()
+    }
+}
+
+impl PartialEq<[u8]> for HeaderValue {
+    #[inline]
+    fn eq(&self, other: &[u8]) -> bool {
+        self.inner == other
+    }
+}
+
+impl PartialOrd<str> for HeaderValue {
+    #[inline]
+    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
+        (*self.inner).partial_cmp(other.as_bytes())
+    }
+}
+
+impl PartialOrd<[u8]> for HeaderValue {
+    #[inline]
+    fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
+        (*self.inner).partial_cmp(other)
+    }
+}
+
+impl PartialEq<HeaderValue> for str {
+    #[inline]
+    fn eq(&self, other: &HeaderValue) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialEq<HeaderValue> for [u8] {
+    #[inline]
+    fn eq(&self, other: &HeaderValue) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<HeaderValue> for str {
+    #[inline]
+    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
+        self.as_bytes().partial_cmp(other.as_bytes())
+    }
+}
+
+impl PartialOrd<HeaderValue> for [u8] {
+    #[inline]
+    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
+        self.partial_cmp(other.as_bytes())
+    }
+}
+
+impl PartialEq<String> for HeaderValue {
+    #[inline]
+    fn eq(&self, other: &String) -> bool {
+        *self == &other[..]
+    }
+}
+
+impl PartialOrd<String> for HeaderValue {
+    #[inline]
+    fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
+        self.inner.partial_cmp(other.as_bytes())
+    }
+}
+
+impl PartialEq<HeaderValue> for String {
+    #[inline]
+    fn eq(&self, other: &HeaderValue) -> bool {
+        *other == *self
+    }
+}
+
+impl PartialOrd<HeaderValue> for String {
+    #[inline]
+    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
+        self.as_bytes().partial_cmp(other.as_bytes())
+    }
+}
+
+impl<'a> PartialEq<HeaderValue> for &'a HeaderValue {
+    #[inline]
+    fn eq(&self, other: &HeaderValue) -> bool {
+        **self == *other
+    }
+}
+
+impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue {
+    #[inline]
+    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
+        (**self).partial_cmp(other)
+    }
+}
+
+impl<'a, T: ?Sized> PartialEq<&'a T> for HeaderValue
+where
+    HeaderValue: PartialEq<T>,
+{
+    #[inline]
+    fn eq(&self, other: &&'a T) -> bool {
+        *self == **other
+    }
+}
+
+impl<'a, T: ?Sized> PartialOrd<&'a T> for HeaderValue
+where
+    HeaderValue: PartialOrd<T>,
+{
+    #[inline]
+    fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
+        self.partial_cmp(*other)
+    }
+}
+
+impl<'a> PartialEq<HeaderValue> for &'a str {
+    #[inline]
+    fn eq(&self, other: &HeaderValue) -> bool {
+        *other == *self
+    }
+}
+
+impl<'a> PartialOrd<HeaderValue> for &'a str {
+    #[inline]
+    fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
+        self.as_bytes().partial_cmp(other.as_bytes())
+    }
+}
+
+#[test]
+fn test_try_from() {
+    HeaderValue::try_from(vec![127]).unwrap_err();
+}
+
+#[test]
+fn test_debug() {
+    let cases = &[
+        ("hello", "\"hello\""),
+        ("hello \"world\"", "\"hello \\\"world\\\"\""),
+        ("\u{7FFF}hello", "\"\\xe7\\xbf\\xbfhello\""),
+    ];
+
+    for &(value, expected) in cases {
+        let val = HeaderValue::from_bytes(value.as_bytes()).unwrap();
+        let actual = format!("{:?}", val);
+        assert_eq!(expected, actual);
+    }
+
+    let mut sensitive = HeaderValue::from_static("password");
+    sensitive.set_sensitive(true);
+    assert_eq!("Sensitive", format!("{:?}", sensitive));
+}