Add Transfer-Encoding and TE headers

src/lib.rs

@@ -126,6 +126,9 @@ pub mod mime;
 pub mod other;
 pub mod proxies;
 pub mod server;
+pub mod trace;
+pub mod transfer;
+pub mod upgrade;
 
 mod body;
 mod error;
@@ -139,9 +142,6 @@ mod status;
 mod status_code;
 mod version;
 
-pub mod trace;
-pub mod upgrade;
-
 pub use body::Body;
 pub use error::{Error, Result};
 pub use method::Method;

src/transfer/encoding.rs

@@ -0,0 +1,64 @@
+use crate::headers::HeaderValue;
+use std::fmt::{self, Display};
+
+/// Available compression algorithms.
+///
+/// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Transfer-Encoding#Directives)
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum Encoding {
+ /// Send a series of chunks.
+ Chunked,
+ /// The Gzip encoding.
+ Gzip,
+ /// The Deflate encoding.
+ Deflate,
+ /// The Brotli encoding.
+ Brotli,
+ /// The Zstd encoding.
+ Zstd,
+ /// No encoding.
+ Identity,
+}
+
+impl Encoding {
+ /// Parses a given string into its corresponding encoding.
+ pub(crate) fn from_str(s: &str) -> Option<Encoding> {
+ let s = s.trim();
+
+ // We're dealing with an empty string.
+ if s.is_empty() {
+ return None;
+ }
+
+ match s {
+ "chunked" => Some(Encoding::Chunked),
+ "gzip" => Some(Encoding::Gzip),
+ "deflate" => Some(Encoding::Deflate),
+ "br" => Some(Encoding::Brotli),
+ "zstd" => Some(Encoding::Zstd),
+ "identity" => Some(Encoding::Identity),
+ _ => None,
+ }
+ }
+}
+
+impl Display for Encoding {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Encoding::Gzip => write!(f, "gzip"),
+ Encoding::Deflate => write!(f, "deflate"),
+ Encoding::Brotli => write!(f, "br"),
+ Encoding::Zstd => write!(f, "zstd"),
+ Encoding::Identity => write!(f, "identity"),
+ Encoding::Chunked => write!(f, "chunked"),
+ }
+ }
+}
+
+impl From<Encoding> for HeaderValue {
+ fn from(directive: Encoding) -> Self {
+ let s = directive.to_string();
+ unsafe { HeaderValue::from_bytes_unchecked(s.into_bytes()) }
+ }
+}

src/transfer/encoding_proposal.rs

@@ -0,0 +1,147 @@
+use crate::ensure;
+use crate::headers::HeaderValue;
+use crate::transfer::Encoding;
+use crate::utils::parse_weight;
+
+use std::cmp::{Ordering, PartialEq};
+use std::ops::{Deref, DerefMut};
+
+/// A proposed `Encoding` in `AcceptEncoding`.
+///
+/// [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE#Directives)
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct EncodingProposal {
+ /// The proposed encoding.
+ pub(crate) encoding: Encoding,
+
+ /// The weight of the proposal.
+ ///
+ /// This is a number between 0.0 and 1.0, and is max 3 decimal points.
+ weight: Option<f32>,
+}
+
+impl EncodingProposal {
+ /// Create a new instance of `EncodingProposal`.
+ pub fn new(encoding: impl Into<Encoding>, weight: Option<f32>) -> crate::Result<Self> {
+ if let Some(weight) = weight {
+ ensure!(
+ weight.is_sign_positive() && weight <= 1.0,
+ "EncodingProposal should have a weight between 0.0 and 1.0"
+ )
+ }
+
+ Ok(Self {
+ encoding: encoding.into(),
+ weight,
+ })
+ }
+
+ /// Get the proposed encoding.
+ pub fn encoding(&self) -> &Encoding {
+ &self.encoding
+ }
+
+ /// Get the weight of the proposal.
+ pub fn weight(&self) -> Option<f32> {
+ self.weight
+ }
+
+ pub(crate) fn from_str(s: &str) -> crate::Result<Option<Self>> {
+ let mut parts = s.split(';');
+ let encoding = match Encoding::from_str(parts.next().unwrap()) {
+ Some(encoding) => encoding,
+ None => return Ok(None),
+ };
+ let weight = parts.next().map(parse_weight).transpose()?;
+
+ Ok(Some(Self::new(encoding, weight)?))
+ }
+}
+
+impl From<Encoding> for EncodingProposal {
+ fn from(encoding: Encoding) -> Self {
+ Self {
+ encoding,
+ weight: None,
+ }
+ }
+}
+
+impl PartialEq<Encoding> for EncodingProposal {
+ fn eq(&self, other: &Encoding) -> bool {
+ self.encoding == *other
+ }
+}
+
+impl PartialEq<Encoding> for &EncodingProposal {
+ fn eq(&self, other: &Encoding) -> bool {
+ self.encoding == *other
+ }
+}
+
+impl Deref for EncodingProposal {
+ type Target = Encoding;
+ fn deref(&self) -> &Self::Target {
+ &self.encoding
+ }
+}
+
+impl DerefMut for EncodingProposal {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.encoding
+ }
+}
+
+// NOTE: Firefox populates Accept-Encoding as `gzip, deflate, br`. This means
+// when parsing encodings we should choose the last value in the list under
+// equal weights. This impl doesn't know which value was passed later, so that
+// behavior needs to be handled separately.
+//
+// NOTE: This comparison does not include a notion of `*` (any value is valid).
+// that needs to be handled separately.
+impl PartialOrd for EncodingProposal {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ match (self.weight, other.weight) {
+ (Some(left), Some(right)) => left.partial_cmp(&right),
+ (Some(_), None) => Some(Ordering::Greater),
+ (None, Some(_)) => Some(Ordering::Less),
+ (None, None) => None,
+ }
+ }
+}
+
+impl From<EncodingProposal> for HeaderValue {
+ fn from(entry: EncodingProposal) -> HeaderValue {
+ let s = match entry.weight {
+ Some(weight) => format!("{};q={:.3}", entry.encoding, weight),
+ None => entry.encoding.to_string(),
+ };
+ unsafe { HeaderValue::from_bytes_unchecked(s.into_bytes()) }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn smoke() -> crate::Result<()> {
+ let _ = EncodingProposal::new(Encoding::Gzip, Some(0.0)).unwrap();
+ let _ = EncodingProposal::new(Encoding::Gzip, Some(0.5)).unwrap();
+ let _ = EncodingProposal::new(Encoding::Gzip, Some(1.0)).unwrap();
+ Ok(())
+ }
+
+ #[test]
+ fn error_code_500() -> crate::Result<()> {
+ let err = EncodingProposal::new(Encoding::Gzip, Some(1.1)).unwrap_err();
+ assert_eq!(err.status(), 500);
+
+ let err = EncodingProposal::new(Encoding::Gzip, Some(-0.1)).unwrap_err();
+ assert_eq!(err.status(), 500);
+
+ let err = EncodingProposal::new(Encoding::Gzip, Some(-0.0)).unwrap_err();
+ assert_eq!(err.status(), 500);
+ Ok(())
+ }
+}

src/transfer/mod.rs

@@ -0,0 +1,13 @@
+//! HTTP transfer headers.
+//!
+//! [MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#Transfer_coding)
+
+mod encoding;
+mod encoding_proposal;
+mod te;
+mod transfer_encoding;
+
+pub use encoding::Encoding;
+pub use encoding_proposal::EncodingProposal;
+pub use te::TE;
+pub use transfer_encoding::TransferEncoding;