Merge pull request #209 from http-rs/timing-allow-origin

Timing allow origin

Author: yoshuawuyts

src/headers/constants.rs

@@ -125,6 +125,7 @@ pub const PRAGMA: HeaderName = HeaderName::from_lowercase_str("pragma");
 
 ///  The `Proxy-Authenticate` Header
 pub const PROXY_AUTHENTICATE: HeaderName = HeaderName::from_lowercase_str("proxy-authenticate");
+
 ///  The `Proxy-Authorization` Header
 pub const PROXY_AUTHORIZATION: HeaderName = HeaderName::from_lowercase_str("proxy-authorization");
 
@@ -143,6 +144,9 @@ pub const SERVER_TIMING: HeaderName = HeaderName::from_lowercase_str("server-tim
 ///  The `Te` Header
 pub const TE: HeaderName = HeaderName::from_lowercase_str("te");
 
+///  The `Timing-Allow-Origin` Header
+pub const TIMING_ALLOW_ORIGIN: HeaderName = HeaderName::from_lowercase_str("timing-allow-origin");
+
 ///  The `Traceparent` Header
 pub const TRACEPARENT: HeaderName = HeaderName::from_lowercase_str("traceparent");
 

src/lib.rs

@@ -131,9 +131,9 @@ mod status;
 mod status_code;
 mod version;
 
+pub mod trace;
 cfg_unstable! {
     pub mod upgrade;
-    pub mod trace;
 
     mod client;
     mod server;

src/trace/allow_origin.rs

@@ -0,0 +1,333 @@
+//! Specify origins that are allowed to see values via the Resource Timing API.
+//!
+//! # Specifications
+//!
+//! - [W3C Timing-Allow-Origin header](https://w3c.github.io/resource-timing/#sec-timing-allow-origin)
+//! - [WhatWG Fetch Origin header](https://fetch.spec.whatwg.org/#origin-header)
+//!
+//! # Examples
+//!
+//! ```
+//! # fn main() -> http_types::Result<()> {
+//! #
+//! use http_types::Response;
+//! use http_types::trace::{AllowOrigin, Origin};
+//!
+//! let mut origins = AllowOrigin::new();
+//! origins.push(Origin::Wildcard);
+//!
+//! let mut res = Response::new(200);
+//! origins.apply(&mut res);
+//!
+//! let origins = AllowOrigin::from_headers(res)?.unwrap();
+//! let origin = origins.iter().next().unwrap();
+//! assert_eq!(origin, &Origin::Wildcard);
+//! #
+//! # Ok(()) }
+//! ```
+
+use crate::headers::{HeaderName, HeaderValue, Headers, ToHeaderValues, TIMING_ALLOW_ORIGIN};
+use crate::{Status, Url};
+
+use std::fmt::Write;
+use std::fmt::{self, Debug};
+use std::iter::Iterator;
+use std::option;
+use std::slice;
+
+/// Specify origins that are allowed to see values via the Resource Timing API.
+///
+/// # Examples
+///
+/// ```
+/// # fn main() -> http_types::Result<()> {
+/// #
+/// use http_types::Response;
+/// use http_types::trace::{AllowOrigin, Origin};
+///
+/// let mut origins = AllowOrigin::new();
+/// origins.push(Origin::Wildcard);
+///
+/// let mut res = Response::new(200);
+/// origins.apply(&mut res);
+///
+/// let origins = AllowOrigin::from_headers(res)?.unwrap();
+/// let origin = origins.iter().next().unwrap();
+/// assert_eq!(origin, &Origin::Wildcard);
+/// #
+/// # Ok(()) }
+/// ```
+#[derive(Clone, Eq, PartialEq)]
+pub struct AllowOrigin {
+    origins: Vec<Origin>,
+}
+
+impl AllowOrigin {
+    /// Create a new instance of `AllowOrigin`.
+    pub fn new() -> Self {
+        Self { origins: vec![] }
+    }
+
+    /// Create an instance of `AllowOrigin` from a `Headers` instance.
+    ///
+    /// # Implementation note
+    ///
+    /// A header value of `"null"` is treated the same as if no header was sent.
+    pub fn from_headers(headers: impl AsRef<Headers>) -> crate::Result<Option<Self>> {
+        let headers = match headers.as_ref().get(TIMING_ALLOW_ORIGIN) {
+            Some(headers) => headers,
+            None => return Ok(None),
+        };
+
+        let mut origins = vec![];
+        for header in headers {
+            for origin in header.as_str().split(',') {
+                match origin.trim_start() {
+                    "*" => origins.push(Origin::Wildcard),
+                    r#""null""# => continue,
+                    origin => {
+                        let url = Url::parse(origin).status(400)?;
+                        origins.push(Origin::Url(url));
+                    }
+                }
+            }
+        }
+
+        Ok(Some(Self { origins }))
+    }
+
+    /// Append an origin to the list of origins.
+    pub fn push(&mut self, origin: impl Into<Origin>) {
+        self.origins.push(origin.into());
+    }
+
+    /// Insert a `HeaderName` + `HeaderValue` pair into a `Headers` instance.
+    pub fn apply(&self, mut headers: impl AsMut<Headers>) {
+        headers.as_mut().insert(TIMING_ALLOW_ORIGIN, self.value());
+    }
+
+    /// Get the `HeaderName`.
+    pub fn name(&self) -> HeaderName {
+        TIMING_ALLOW_ORIGIN
+    }
+
+    /// Get the `HeaderValue`.
+    pub fn value(&self) -> HeaderValue {
+        let mut output = String::new();
+        for (n, origin) in self.origins.iter().enumerate() {
+            let origin: HeaderValue = origin.clone().into();
+            match n {
+                0 => write!(output, "{}", origin).unwrap(),
+                _ => write!(output, ", {}", origin).unwrap(),
+            };
+        }
+
+        // SAFETY: the internal string is validated to be ASCII.
+        unsafe { HeaderValue::from_bytes_unchecked(output.into()) }
+    }
+
+    /// An iterator visiting all server timings.
+    pub fn iter(&self) -> Iter<'_> {
+        Iter {
+            inner: self.origins.iter(),
+        }
+    }
+
+    /// An iterator visiting all server timings.
+    pub fn iter_mut(&mut self) -> IterMut<'_> {
+        IterMut {
+            inner: self.origins.iter_mut(),
+        }
+    }
+}
+
+impl IntoIterator for AllowOrigin {
+    type Item = Origin;
+    type IntoIter = IntoIter;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter {
+            inner: self.origins.into_iter(),
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a AllowOrigin {
+    type Item = &'a Origin;
+    type IntoIter = Iter<'a>;
+
+    // #[inline]serv
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a mut AllowOrigin {
+    type Item = &'a mut Origin;
+    type IntoIter = IterMut<'a>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter_mut()
+    }
+}
+
+/// A borrowing iterator over entries in `AllowOrigin`.
+#[derive(Debug)]
+pub struct IntoIter {
+    inner: std::vec::IntoIter<Origin>,
+}
+
+impl Iterator for IntoIter {
+    type Item = Origin;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+/// A lending iterator over entries in `AllowOrigin`.
+#[derive(Debug)]
+pub struct Iter<'a> {
+    inner: slice::Iter<'a, Origin>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a Origin;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+/// A mutable iterator over entries in `AllowOrigin`.
+#[derive(Debug)]
+pub struct IterMut<'a> {
+    inner: slice::IterMut<'a, Origin>,
+}
+
+impl<'a> Iterator for IterMut<'a> {
+    type Item = &'a mut Origin;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+// Conversion from `AllowOrigin` -> `HeaderValue`.
+impl ToHeaderValues for AllowOrigin {
+    type Iter = option::IntoIter<HeaderValue>;
+    fn to_header_values(&self) -> crate::Result<Self::Iter> {
+        Ok(self.value().to_header_values().unwrap())
+    }
+}
+
+impl Debug for AllowOrigin {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut list = f.debug_list();
+        for origin in &self.origins {
+            list.entry(origin);
+        }
+        list.finish()
+    }
+}
+
+/// An origin passed into `AllowOrigin`.
+///
+/// Values can either be `Url` or `Wildcard`. `"null"` values are skipped during parsing.
+//
+// NOTE: this origin is different than the origin in the fetch spec. It needs to
+// be its own type.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum Origin {
+    /// An origin URL.
+    Url(Url),
+    /// Allow all origins.
+    Wildcard,
+}
+
+impl From<Url> for Origin {
+    fn from(url: Url) -> Self {
+        Origin::Url(url)
+    }
+}
+
+impl From<Origin> for HeaderValue {
+    fn from(entry: Origin) -> HeaderValue {
+        unsafe {
+            match entry {
+                Origin::Url(url) => {
+                    HeaderValue::from_bytes_unchecked(format!("{}", url).into_bytes())
+                }
+                Origin::Wildcard => {
+                    HeaderValue::from_bytes_unchecked(String::from("*").into_bytes())
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::headers::Headers;
+
+    #[test]
+    fn smoke() -> crate::Result<()> {
+        let mut origins = AllowOrigin::new();
+        origins.push(Origin::Wildcard);
+
+        let mut headers = Headers::new();
+        origins.apply(&mut headers);
+
+        let origins = AllowOrigin::from_headers(headers)?.unwrap();
+        let origin = origins.iter().next().unwrap();
+        assert_eq!(origin, &Origin::Wildcard);
+        Ok(())
+    }
+
+    #[test]
+    fn multi() -> crate::Result<()> {
+        let mut origins = AllowOrigin::new();
+        origins.push(Origin::Wildcard);
+        origins.push(Origin::Url(Url::parse("https://mozilla.org/")?));
+
+        let mut headers = Headers::new();
+        origins.apply(&mut headers);
+
+        let origins = AllowOrigin::from_headers(headers)?.unwrap();
+        let mut origins = origins.iter();
+        let origin = origins.next().unwrap();
+        assert!(matches!(origin, Origin::Wildcard));
+
+        let origin = origins.next().unwrap();
+        let rhs = Url::parse("https://mozilla.org/")?;
+        assert_eq!(origin, &Origin::Url(rhs));
+        Ok(())
+    }
+
+    #[test]
+    fn bad_request_on_parse_error() -> crate::Result<()> {
+        let mut headers = Headers::new();
+        headers.insert(TIMING_ALLOW_ORIGIN, "server; <nori ate your param omnom>");
+        let err = AllowOrigin::from_headers(headers).unwrap_err();
+        assert_eq!(err.status(), 400);
+        Ok(())
+    }
+}

src/trace/mod.rs

@@ -6,12 +6,16 @@
 //!
 //! # Specifications
 //!
-//! - [W3C Trace-Context headers](https://w3c.github.io/trace-context/)
-//! - [W3C Server-Timing headers](https://w3c.github.io/server-timing/#the-server-timing-header-field)
+//! - [W3C Trace-Context header](https://w3c.github.io/trace-context/)
+//! - [W3C Server-Timing header](https://w3c.github.io/server-timing/#the-server-timing-header-field)
+//! - [W3C Timing-Allow-Origin header](https://w3c.github.io/resource-timing/#sec-timing-allow-origin)
 
+pub mod allow_origin;
 pub mod server_timing;
 mod trace_context;
 
+#[doc(inline)]
+pub use allow_origin::{AllowOrigin, Origin};
 #[doc(inline)]
 pub use server_timing::{Metric, ServerTiming};
 pub use trace_context::TraceContext;

src/trace/server_timing/metric.rs

@@ -48,7 +48,7 @@ impl Metric {
 
     /// The timing description.
     pub fn description(&self) -> Option<&str> {
-        self.desc.as_ref().map(|s| s.as_str())
+        self.desc.as_deref()
     }
 }