use std::{
future::Future,
pin::Pin,
sync::Arc,
task::{ready, Context, Poll},
};
use bytes::Bytes;
use http::{header, request::Parts, HeaderMap, HeaderValue, Method, Request, Response};
use hyper::body::Body;
use hyper::service::Service;
use pin_project_lite::pin_project;
use crate::{allow_origin::AllowOriginFuture, config::CorsBuilder, header_buf::HeaderBuf};
#[derive(Debug, Clone)]
#[must_use]
pub struct Cors<S> {
inner: S,
config: Arc<CorsBuilder>,
}
impl<S> Cors<S> {
pub fn inner(&self) -> &S {
&self.inner
}
pub fn inner_mut(&mut self) -> &mut S {
&mut self.inner
}
pub fn config(&self) -> &CorsBuilder {
&self.config
}
pub(crate) fn from_parts(inner: S, config: CorsBuilder) -> Self {
Self {
inner,
config: Arc::new(config),
}
}
}
pub fn builder() -> CorsBuilder {
CorsBuilder::new()
}
impl<S, ReqB, ResB> Service<Request<ReqB>> for Cors<S>
where
S: Service<Request<ReqB>, Response = Response<ResB>> + Clone,
ResB: Body<Data = Bytes> + Default + Send + 'static,
{
type Response = Response<ResB>;
type Error = S::Error;
type Future = CorsFuture<S, ReqB, S::Future, ResB>;
fn call(&self, req: Request<ReqB>) -> Self::Future {
let (parts, body) = req.into_parts();
let origin = parts.headers.get(&header::ORIGIN).cloned();
let is_preflight = is_preflight_request(&parts);
let is_websocket_upgrade = is_websocket_upgrade_request(&parts);
let allow_origin_future = self.config.allow_origin.to_future(origin.as_ref(), &parts);
let has_origin = allow_origin_future.has_origin();
let mut common_headers = HeaderBuf::default();
common_headers.push_opt(self.config.vary.to_header());
let lazy_factory = LazyHeaders {
allow_credentials: self.config.allow_credentials.clone(),
allow_methods: self.config.allow_methods.clone(),
allow_headers: self.config.allow_headers.clone(),
expose_headers: self.config.expose_headers.clone(),
max_age: self.config.max_age.clone(),
};
if is_preflight && !self.config.deliver_preflight {
CorsFuture::Preflight {
allow_origin_future,
headers: common_headers,
lazy: lazy_factory,
parts,
has_origin,
origin,
deliver_non_allowed_origin: self.config.deliver_non_allowed_origin,
rejection_status: self.config.rejection_status,
_body: std::marker::PhantomData,
}
} else {
CorsFuture::Forward {
allow_origin_future,
allow_origin_complete: false,
service: Some(self.inner.clone()),
body: Some(body),
inner: None,
headers: common_headers,
lazy: Some(lazy_factory),
parts: Some(parts),
is_preflight,
has_origin,
origin,
deliver_non_allowed_origin: self.config.deliver_non_allowed_origin,
rejection_status: self.config.rejection_status,
reject_websocket_upgrade: is_websocket_upgrade
&& !self.config.deliver_non_allowed_origin_websocket_upgrade,
_body: std::marker::PhantomData,
}
}
}
}
#[derive(Clone)]
struct LazyHeaders {
allow_credentials: crate::AllowCredentials,
allow_methods: crate::AllowMethods,
allow_headers: crate::AllowHeaders,
expose_headers: crate::ExposeHeaders,
max_age: crate::MaxAge,
}
impl LazyHeaders {
fn compute_into(
&self,
out: &mut HeaderBuf,
parts: &Parts,
origin: Option<&HeaderValue>,
is_preflight: bool,
) {
out.push_opt(self.allow_credentials.to_header(origin, parts));
if is_preflight {
out.push_opt(self.allow_methods.to_header(parts));
out.push_opt(self.allow_headers.to_header(parts));
out.push_opt(self.max_age.to_header(origin, parts));
} else {
out.push_opt(self.expose_headers.to_header(parts));
}
}
}
pin_project! {
#[project = CorsFutureProj]
pub enum CorsFuture<S, ReqB, F, B> {
Forward {
#[pin]
allow_origin_future: AllowOriginFuture,
allow_origin_complete: bool,
service: Option<S>,
body: Option<ReqB>,
#[pin]
inner: Option<F>,
headers: HeaderBuf,
lazy: Option<LazyHeaders>,
parts: Option<Parts>,
is_preflight: bool,
has_origin: bool,
origin: Option<HeaderValue>,
deliver_non_allowed_origin: bool,
rejection_status: http::StatusCode,
reject_websocket_upgrade: bool,
_body: std::marker::PhantomData<fn() -> B>,
},
Preflight {
#[pin]
allow_origin_future: AllowOriginFuture,
headers: HeaderBuf,
lazy: LazyHeaders,
parts: Parts,
has_origin: bool,
origin: Option<HeaderValue>,
deliver_non_allowed_origin: bool,
rejection_status: http::StatusCode,
_body: std::marker::PhantomData<fn() -> B>,
},
}
}
impl<S, ReqB, F, B, E> Future for CorsFuture<S, ReqB, F, B>
where
S: Service<Request<ReqB>, Response = Response<B>, Future = F>,
F: Future<Output = Result<Response<B>, E>>,
B: Body<Data = Bytes> + Default + Send + 'static,
{
type Output = Result<Response<B>, E>;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
match self.project() {
CorsFutureProj::Forward {
allow_origin_future,
allow_origin_complete,
service,
body,
mut inner,
headers,
lazy,
parts,
is_preflight,
has_origin,
origin,
deliver_non_allowed_origin,
rejection_status,
reject_websocket_upgrade,
_body: _,
} => {
if !*allow_origin_complete {
let origin_allowed = match ready!(allow_origin_future.poll(cx)) {
Some((name, value)) => {
headers.push((name, value));
true
}
None => false,
};
*allow_origin_complete = true;
if !origin_allowed
&& *has_origin
&& (!*deliver_non_allowed_origin || *reject_websocket_upgrade)
{
service.take();
body.take();
parts.take();
let mut response = Response::new(B::default());
*response.status_mut() = *rejection_status;
merge_headers(response.headers_mut(), headers);
return Poll::Ready(Ok(response));
}
if origin_allowed {
if let (Some(lazy), Some(parts)) = (lazy.take(), parts.as_ref()) {
lazy.compute_into(headers, parts, origin.as_ref(), *is_preflight);
}
}
if let (Some(svc), Some(parts), Some(body)) =
(service.take(), parts.take(), body.take())
{
inner.set(Some(svc.call(Request::from_parts(parts, body))));
}
}
let inner_pinned = inner
.as_mut()
.as_pin_mut()
.expect("polled after completion");
let mut response = ready!(inner_pinned.poll(cx))?;
merge_headers(response.headers_mut(), headers);
Poll::Ready(Ok(response))
}
CorsFutureProj::Preflight {
allow_origin_future,
headers,
lazy,
parts,
has_origin,
origin,
deliver_non_allowed_origin,
rejection_status,
_body: _,
} => {
let origin_allowed = match ready!(allow_origin_future.poll(cx)) {
Some((name, value)) => {
headers.push((name, value));
true
}
None => false,
};
if !origin_allowed && *has_origin {
let mut response = Response::new(B::default());
if !*deliver_non_allowed_origin {
*response.status_mut() = *rejection_status;
}
merge_headers(response.headers_mut(), headers);
return Poll::Ready(Ok(response));
}
lazy.compute_into(headers, parts, origin.as_ref(), true);
let mut response = Response::new(B::default());
merge_headers(response.headers_mut(), headers);
Poll::Ready(Ok(response))
}
}
}
}
fn is_preflight_request(parts: &Parts) -> bool {
parts.method == Method::OPTIONS
&& parts
.headers
.contains_key(header::ACCESS_CONTROL_REQUEST_METHOD)
}
fn is_websocket_upgrade_request(parts: &Parts) -> bool {
parts.headers.contains_key("sec-websocket-version")
}
fn merge_headers(target: &mut HeaderMap, headers: &HeaderBuf) {
for (name, value) in headers.iter() {
if name == header::VARY {
if let Some(value) = dedup_vary(target, value) {
target.append(name.clone(), value);
}
} else {
target.insert(name.clone(), value.clone());
}
}
}
const DEDUP_VARY_STACK: usize = 128;
fn dedup_vary(target: &HeaderMap, value: &HeaderValue) -> Option<HeaderValue> {
fn already_listed(target: &HeaderMap, tok: &[u8]) -> bool {
target
.get_all(header::VARY)
.iter()
.flat_map(|v| v.as_bytes().split(|&b| b == b','))
.any(|e| e.trim_ascii().eq_ignore_ascii_case(tok))
}
if target.get(header::VARY).is_none() {
return Some(value.clone());
}
let mut stack = [0u8; DEDUP_VARY_STACK];
let mut len = 0usize;
let mut heap: Option<Vec<u8>> = None;
for tok in value.as_bytes().split(|&b| b == b',') {
let tok = tok.trim_ascii();
if tok.is_empty() || already_listed(target, tok) {
continue;
}
let needs_sep = match &heap {
Some(v) => !v.is_empty(),
None => len > 0,
};
let sep_len = if needs_sep { 2 } else { 0 };
let total = sep_len + tok.len();
if heap.is_none() {
if len + total <= DEDUP_VARY_STACK {
if needs_sep {
stack[len..len + 2].copy_from_slice(b", ");
}
stack[len + sep_len..len + total].copy_from_slice(tok);
len += total;
continue;
}
let mut v = Vec::with_capacity(len + total);
v.extend_from_slice(&stack[..len]);
heap = Some(v);
}
let v = heap.as_mut().expect("set on spill");
if needs_sep {
v.extend_from_slice(b", ");
}
v.extend_from_slice(tok);
}
let bytes: &[u8] = match &heap {
Some(v) => v.as_slice(),
None => &stack[..len],
};
if bytes.is_empty() {
return None;
}
HeaderValue::from_bytes(bytes).ok()
}
#[cfg(test)]
mod tests {
use super::*;
use bytes::Bytes;
use http::Request;
use http_body_util::{Empty, Full};
use hyper::service::Service;
use std::future::{ready, Ready};
#[derive(Clone)]
struct Marker;
impl Service<Request<Empty<Bytes>>> for Marker {
type Response = Response<Full<Bytes>>;
type Error = std::convert::Infallible;
type Future = Ready<Result<Self::Response, Self::Error>>;
fn call(&self, _req: Request<Empty<Bytes>>) -> Self::Future {
ready(Ok(Response::new(Full::new(Bytes::new()))))
}
}
#[test]
fn inner_accessor_returns_shared_reference() {
let svc: Cors<Marker> = crate::builder().allow_origin(crate::Any).build(Marker);
let _r: &Marker = svc.inner();
}
#[test]
fn config_accessor_returns_builder_reference() {
let svc: Cors<Marker> = crate::builder().allow_origin(crate::Any).build(Marker);
let _cfg: &CorsBuilder = svc.config();
}
#[test]
fn inner_mut_returns_exclusive_mutable_reference() {
let mut svc: Cors<Marker> = crate::builder().allow_origin(crate::Any).build(Marker);
let r: &mut Marker = svc.inner_mut();
let prev = std::mem::replace(r, Marker);
let _ = prev;
}
#[test]
fn cors_layout_is_arc_backed() {
let size = std::mem::size_of::<Cors<()>>();
assert_eq!(
size,
std::mem::size_of::<usize>(),
"Cors<()> should be one pointer (Arc-backed config); got {size} bytes. \
Did someone inline CorsBuilder back into Cors?"
);
}
#[test]
fn clone_shares_the_config_arc() {
let svc: Cors<Marker> = crate::builder().allow_origin(crate::Any).build(Marker);
let clone = svc.clone();
let p1: *const CorsBuilder = Arc::as_ptr(&svc.config);
let p2: *const CorsBuilder = Arc::as_ptr(&clone.config);
assert_eq!(
p1, p2,
"Cors::clone must share the underlying Arc<CorsBuilder>; got distinct allocations"
);
}
}