net_traits/
response.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5//! The [Response](https://fetch.spec.whatwg.org/#responses) object
6//! resulting from a [fetch operation](https://fetch.spec.whatwg.org/#concept-fetch)
7use std::sync::Mutex;
8use std::sync::atomic::AtomicBool;
9
10use http::HeaderMap;
11use hyper_serde::Serde;
12use malloc_size_of_derive::MallocSizeOf;
13use serde::{Deserialize, Serialize};
14use servo_arc::Arc;
15use servo_url::ServoUrl;
16
17use crate::fetch::headers::extract_mime_type_as_mime;
18use crate::http_status::HttpStatus;
19use crate::{
20    FetchMetadata, FilteredMetadata, Metadata, NetworkError, ReferrerPolicy, ResourceFetchTiming,
21    ResourceTimingType,
22};
23
24/// [Response type](https://fetch.spec.whatwg.org/#concept-response-type)
25#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
26pub enum ResponseType {
27    Basic,
28    Cors,
29    Default,
30    Error(NetworkError),
31    Opaque,
32    OpaqueRedirect,
33}
34
35/// [Response termination reason](https://fetch.spec.whatwg.org/#concept-response-termination-reason)
36#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, Serialize)]
37pub enum TerminationReason {
38    EndUserAbort,
39    Fatal,
40    Timeout,
41}
42
43/// The response body can still be pushed to after fetch
44/// This provides a way to store unfinished response bodies
45#[derive(Clone, Debug, MallocSizeOf, PartialEq)]
46pub enum ResponseBody {
47    Empty, // XXXManishearth is this necessary, or is Done(vec![]) enough?
48    Receiving(Vec<u8>),
49    Done(Vec<u8>),
50}
51
52impl ResponseBody {
53    pub fn is_done(&self) -> bool {
54        match *self {
55            ResponseBody::Done(..) => true,
56            ResponseBody::Empty | ResponseBody::Receiving(..) => false,
57        }
58    }
59}
60
61/// [Cache state](https://fetch.spec.whatwg.org/#concept-response-cache-state)
62#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
63pub enum CacheState {
64    None,
65    Local,
66    Validated,
67    Partial,
68}
69
70/// [Https state](https://fetch.spec.whatwg.org/#concept-response-https-state)
71#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
72pub enum HttpsState {
73    None,
74    Deprecated,
75    Modern,
76}
77
78#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
79pub struct ResponseInit {
80    pub url: ServoUrl,
81    #[serde(
82        deserialize_with = "::hyper_serde::deserialize",
83        serialize_with = "::hyper_serde::serialize"
84    )]
85    #[ignore_malloc_size_of = "Defined in hyper"]
86    pub headers: HeaderMap,
87    pub status_code: u16,
88    pub referrer: Option<ServoUrl>,
89    pub location_url: Option<Result<ServoUrl, String>>,
90}
91
92/// A [Response](https://fetch.spec.whatwg.org/#concept-response) as defined by the Fetch spec
93#[derive(Clone, Debug, MallocSizeOf)]
94pub struct Response {
95    pub response_type: ResponseType,
96    pub termination_reason: Option<TerminationReason>,
97    url: Option<ServoUrl>,
98    pub url_list: Vec<ServoUrl>,
99    pub status: HttpStatus,
100    #[ignore_malloc_size_of = "Defined in hyper"]
101    pub headers: HeaderMap,
102    #[ignore_malloc_size_of = "Mutex heap size undefined"]
103    pub body: Arc<Mutex<ResponseBody>>,
104    pub cache_state: CacheState,
105    pub https_state: HttpsState,
106    pub referrer: Option<ServoUrl>,
107    pub referrer_policy: ReferrerPolicy,
108    /// [CORS-exposed header-name list](https://fetch.spec.whatwg.org/#concept-response-cors-exposed-header-name-list)
109    pub cors_exposed_header_name_list: Vec<String>,
110    /// [Location URL](https://fetch.spec.whatwg.org/#concept-response-location-url)
111    pub location_url: Option<Result<ServoUrl, String>>,
112    /// [Internal response](https://fetch.spec.whatwg.org/#concept-internal-response), only used if the Response
113    /// is a filtered response
114    pub internal_response: Option<Box<Response>>,
115    /// whether or not to try to return the internal_response when asked for actual_response
116    pub return_internal: bool,
117    /// <https://fetch.spec.whatwg.org/#concept-response-aborted>
118    #[ignore_malloc_size_of = "AtomicBool heap size undefined"]
119    pub aborted: Arc<AtomicBool>,
120    /// track network metrics
121    #[ignore_malloc_size_of = "Mutex heap size undefined"]
122    pub resource_timing: Arc<Mutex<ResourceFetchTiming>>,
123
124    /// <https://fetch.spec.whatwg.org/#concept-response-range-requested-flag>
125    pub range_requested: bool,
126}
127
128impl Response {
129    pub fn new(url: ServoUrl, resource_timing: ResourceFetchTiming) -> Response {
130        Response {
131            response_type: ResponseType::Default,
132            termination_reason: None,
133            url: Some(url),
134            url_list: vec![],
135            status: HttpStatus::default(),
136            headers: HeaderMap::new(),
137            body: Arc::new(Mutex::new(ResponseBody::Empty)),
138            cache_state: CacheState::None,
139            https_state: HttpsState::None,
140            referrer: None,
141            referrer_policy: ReferrerPolicy::EmptyString,
142            cors_exposed_header_name_list: vec![],
143            location_url: None,
144            internal_response: None,
145            return_internal: true,
146            aborted: Arc::new(AtomicBool::new(false)),
147            resource_timing: Arc::new(Mutex::new(resource_timing)),
148            range_requested: false,
149        }
150    }
151
152    pub fn from_init(init: ResponseInit, resource_timing_type: ResourceTimingType) -> Response {
153        let mut res = Response::new(init.url, ResourceFetchTiming::new(resource_timing_type));
154        res.location_url = init.location_url;
155        res.headers = init.headers;
156        res.referrer = init.referrer;
157        res.status = HttpStatus::new_raw(init.status_code, vec![]);
158        res
159    }
160
161    pub fn network_error(e: NetworkError) -> Response {
162        Response {
163            response_type: ResponseType::Error(e),
164            termination_reason: None,
165            url: None,
166            url_list: vec![],
167            status: HttpStatus::new_error(),
168            headers: HeaderMap::new(),
169            body: Arc::new(Mutex::new(ResponseBody::Empty)),
170            cache_state: CacheState::None,
171            https_state: HttpsState::None,
172            referrer: None,
173            referrer_policy: ReferrerPolicy::EmptyString,
174            cors_exposed_header_name_list: vec![],
175            location_url: None,
176            internal_response: None,
177            return_internal: true,
178            aborted: Arc::new(AtomicBool::new(false)),
179            resource_timing: Arc::new(Mutex::new(ResourceFetchTiming::new(
180                ResourceTimingType::Error,
181            ))),
182            range_requested: false,
183        }
184    }
185
186    pub fn network_internal_error<T: Into<String>>(msg: T) -> Response {
187        Self::network_error(NetworkError::Internal(msg.into()))
188    }
189
190    pub fn url(&self) -> Option<&ServoUrl> {
191        self.url.as_ref()
192    }
193
194    pub fn is_network_error(&self) -> bool {
195        matches!(self.response_type, ResponseType::Error(..))
196    }
197
198    pub fn get_network_error(&self) -> Option<&NetworkError> {
199        match self.response_type {
200            ResponseType::Error(ref e) => Some(e),
201            _ => None,
202        }
203    }
204
205    pub fn actual_response(&self) -> &Response {
206        if self.return_internal && self.internal_response.is_some() {
207            self.internal_response.as_ref().unwrap()
208        } else {
209            self
210        }
211    }
212
213    pub fn actual_response_mut(&mut self) -> &mut Response {
214        if self.return_internal && self.internal_response.is_some() {
215            self.internal_response.as_mut().unwrap()
216        } else {
217            self
218        }
219    }
220
221    pub fn to_actual(self) -> Response {
222        if self.return_internal && self.internal_response.is_some() {
223            *self.internal_response.unwrap()
224        } else {
225            self
226        }
227    }
228
229    pub fn get_resource_timing(&self) -> Arc<Mutex<ResourceFetchTiming>> {
230        Arc::clone(&self.resource_timing)
231    }
232
233    /// Convert to a filtered response, of type `filter_type`.
234    /// Do not use with type Error or Default
235    #[rustfmt::skip]
236    pub fn to_filtered(self, filter_type: ResponseType) -> Response {
237        match filter_type {
238            ResponseType::Default |
239            ResponseType::Error(..) => panic!(),
240            _ => (),
241        }
242
243        let old_response = self.to_actual();
244
245        if let ResponseType::Error(e) = old_response.response_type {
246            return Response::network_error(e);
247        }
248
249        let old_headers = old_response.headers.clone();
250        let exposed_headers = old_response.cors_exposed_header_name_list.clone();
251        let mut response = old_response.clone();
252        response.internal_response = Some(Box::new(old_response));
253        response.response_type = filter_type;
254
255        match response.response_type {
256            ResponseType::Default |
257            ResponseType::Error(..) => unreachable!(),
258
259            ResponseType::Basic => {
260                let headers = old_headers.iter().filter(|(name, _)| {
261                    !matches!(&*name.as_str().to_ascii_lowercase(), "set-cookie" | "set-cookie2")
262                }).map(|(n, v)| (n.clone(), v.clone())).collect();
263                response.headers = headers;
264            },
265
266            ResponseType::Cors => {
267                let headers = old_headers.iter().filter(|(name, _)| {
268                    match &*name.as_str().to_ascii_lowercase() {
269                        "cache-control" | "content-language" | "content-length" | "content-type" |
270                        "expires" | "last-modified" | "pragma" => true,
271                        "set-cookie" | "set-cookie2" => false,
272                        header => {
273                            exposed_headers.iter().any(|h| *header == h.as_str().to_ascii_lowercase())
274                        }
275                    }
276                }).map(|(n, v)| (n.clone(), v.clone())).collect();
277                response.headers = headers;
278            },
279
280            ResponseType::Opaque => {
281                response.url_list = vec![];
282                response.url = None;
283                response.headers = HeaderMap::new();
284                response.status = HttpStatus::new_error();
285                response.body = Arc::new(Mutex::new(ResponseBody::Empty));
286                response.cache_state = CacheState::None;
287            },
288
289            ResponseType::OpaqueRedirect => {
290                response.headers = HeaderMap::new();
291                response.status = HttpStatus::new_error();
292                response.body = Arc::new(Mutex::new(ResponseBody::Empty));
293                response.cache_state = CacheState::None;
294            },
295        }
296
297        response
298    }
299
300    pub fn metadata(&self) -> Result<FetchMetadata, NetworkError> {
301        fn init_metadata(response: &Response, url: &ServoUrl) -> Metadata {
302            let mut metadata = Metadata::default(url.clone());
303            metadata.set_content_type(extract_mime_type_as_mime(&response.headers).as_ref());
304            metadata.location_url.clone_from(&response.location_url);
305            metadata.headers = Some(Serde(response.headers.clone()));
306            metadata.status.clone_from(&response.status);
307            metadata.https_state = response.https_state;
308            metadata.referrer.clone_from(&response.referrer);
309            metadata.referrer_policy = response.referrer_policy;
310            metadata.redirected = response.actual_response().url_list.len() > 1;
311            metadata
312        }
313
314        if let Some(error) = self.get_network_error() {
315            return Err(error.clone());
316        }
317
318        let metadata = self.url.as_ref().map(|url| init_metadata(self, url));
319
320        if let Some(ref response) = self.internal_response {
321            match response.url {
322                Some(ref url) => {
323                    let unsafe_metadata = init_metadata(response, url);
324
325                    match self.response_type {
326                        ResponseType::Basic => Ok(FetchMetadata::Filtered {
327                            filtered: FilteredMetadata::Basic(metadata.unwrap()),
328                            unsafe_: unsafe_metadata,
329                        }),
330                        ResponseType::Cors => Ok(FetchMetadata::Filtered {
331                            filtered: FilteredMetadata::Cors(metadata.unwrap()),
332                            unsafe_: unsafe_metadata,
333                        }),
334                        ResponseType::Default => unreachable!(),
335                        ResponseType::Error(ref network_err) => Err(network_err.clone()),
336                        ResponseType::Opaque => Ok(FetchMetadata::Filtered {
337                            filtered: FilteredMetadata::Opaque,
338                            unsafe_: unsafe_metadata,
339                        }),
340                        ResponseType::OpaqueRedirect => Ok(FetchMetadata::Filtered {
341                            filtered: FilteredMetadata::OpaqueRedirect(url.clone()),
342                            unsafe_: unsafe_metadata,
343                        }),
344                    }
345                },
346                None => Err(NetworkError::Internal(
347                    "No url found in unsafe response".to_owned(),
348                )),
349            }
350        } else {
351            assert_eq!(self.response_type, ResponseType::Default);
352            Ok(FetchMetadata::Unfiltered(metadata.unwrap()))
353        }
354    }
355}
net_traits/response.rs

net_traits/
response.rs
