humphrey 0.7.0

A Performance-Focused, Dependency-Free Web Server.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Contains the CORS implementation for Humphrey.

use crate::http::headers::{HeaderLike, HeaderType, Headers};
use crate::http::method::Method;

#[derive(Clone)]
enum Wildcardable<T> {
    Wildcard,
    Value(T),
}

/// Represents a CORS configuration.
///
/// Cross-origin resource sharing (CORS) is a mechanism that allows a server to indicate any origins other than
///   its own from which a browser should permit loading resources.
///
/// Learn more about CORS at the [MDN docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
#[derive(Clone, Default)]
pub struct Cors {
    allowed_origins: Wildcardable<Vec<String>>,
    allowed_methods: Wildcardable<Vec<Method>>,
    allowed_headers: Wildcardable<Vec<String>>,
}

impl Cors {
    /// Creates a new CORS configuration with no allowed origins.
    pub fn new() -> Self {
        Self::default()
    }

    /// Creates a new CORS configuration with every origin, header and method allowed.
    ///
    /// This corresponds to the following headers:
    /// ```text
    /// Access-Control-Allow-Origin: *
    /// Access-Control-Allow-Headers: *
    /// Access-Control-Allow-Methods: * (although this is implied)
    /// ```
    pub fn wildcard() -> Self {
        Self {
            allowed_origins: Wildcardable::Wildcard,
            allowed_methods: Wildcardable::Wildcard,
            allowed_headers: Wildcardable::Wildcard,
        }
    }

    /// Sets the allowed origins to "*", allowing all origins.
    pub fn with_wildcard_origin(mut self) -> Self {
        self.allowed_origins = Wildcardable::Wildcard;
        self
    }

    /// Sets the allowed methods to "*", allowing all methods.
    pub fn with_wildcard_methods(mut self) -> Self {
        self.allowed_methods = Wildcardable::Wildcard;
        self
    }

    /// Sets the allowed headers to "*", allowing all headers.
    pub fn with_wildcard_headers(mut self) -> Self {
        self.allowed_headers = Wildcardable::Wildcard;
        self
    }

    /// Adds the allowed origin.
    pub fn with_origin(mut self, origin: &str) -> Self {
        match self.allowed_origins {
            Wildcardable::Wildcard => (),
            Wildcardable::Value(ref mut origins) => origins.push(origin.to_string()),
        }
        self
    }

    /// Adds the allowed method.
    pub fn with_method(mut self, method: Method) -> Self {
        match self.allowed_methods {
            Wildcardable::Wildcard => (),
            Wildcardable::Value(ref mut methods) => methods.push(method),
        }
        self
    }

    /// Adds the allowed header.
    pub fn with_header(mut self, header: impl HeaderLike) -> Self {
        match self.allowed_headers {
            Wildcardable::Wildcard => (),
            Wildcardable::Value(ref mut headers) => headers.push(header.to_header().to_string()),
        }
        self
    }

    /// Sets the appropriate headers for the CORS configuration.
    pub(crate) fn set_headers(&self, headers: &mut Headers) {
        if headers.get(HeaderType::AccessControlAllowOrigin).is_none() {
            match self.allowed_origins {
                Wildcardable::Wildcard => {
                    headers.add(HeaderType::AccessControlAllowOrigin, "*");
                }
                Wildcardable::Value(ref origins) if !origins.is_empty() => {
                    headers.add(HeaderType::AccessControlAllowOrigin, &origins.join(", "));
                }
                _ => (),
            }
        }

        if headers.get(HeaderType::AccessControlAllowMethods).is_none() {
            match self.allowed_methods {
                Wildcardable::Value(ref methods) if !methods.is_empty() => {
                    headers.add(
                        HeaderType::AccessControlAllowMethods,
                        &methods
                            .iter()
                            .map(|m| m.to_string())
                            .collect::<Vec<_>>()
                            .join(", "),
                    );
                }
                _ => (),
            }
        }

        if headers.get(HeaderType::AccessControlAllowHeaders).is_none() {
            match self.allowed_headers {
                Wildcardable::Wildcard => {
                    headers.add(HeaderType::AccessControlAllowHeaders, "*");
                }
                Wildcardable::Value(ref allowed_headers) if !allowed_headers.is_empty() => {
                    headers.add(
                        HeaderType::AccessControlAllowHeaders,
                        &allowed_headers.join(", "),
                    );
                }
                _ => (),
            }
        }
    }
}

impl<T> Default for Wildcardable<T>
where
    T: Default,
{
    fn default() -> Self {
        Wildcardable::Value(T::default())
    }
}