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::atomic::AtomicBool;
8
9use http::HeaderMap;
10use hyper_serde::Serde;
11use malloc_size_of_derive::MallocSizeOf;
12use parking_lot::Mutex;
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, TlsSecurityInfo,
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, Deserialize, MallocSizeOf, PartialEq, Serialize)]
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/// <https://fetch.spec.whatwg.org/#response-redirect-taint>
62#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize)]
63pub enum RedirectTaint {
64    #[default]
65    SameOrigin,
66    SameSite,
67    CrossSite,
68}
69
70/// [Cache state](https://fetch.spec.whatwg.org/#concept-response-cache-state)
71#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, Serialize)]
72pub enum CacheState {
73    None,
74    Local,
75    Validated,
76    Partial,
77}
78
79/// [Https state](https://fetch.spec.whatwg.org/#concept-response-https-state)
80#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
81pub enum HttpsState {
82    None,
83    Deprecated,
84    Modern,
85}
86
87#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
88pub struct ResponseInit {
89    pub url: ServoUrl,
90    #[serde(
91        deserialize_with = "::hyper_serde::deserialize",
92        serialize_with = "::hyper_serde::serialize"
93    )]
94    #[ignore_malloc_size_of = "Defined in hyper"]
95    pub headers: HeaderMap,
96    pub status_code: u16,
97    pub referrer: Option<ServoUrl>,
98    pub location_url: Option<Result<ServoUrl, String>>,
99}
100
101/// A [Response](https://fetch.spec.whatwg.org/#concept-response) as defined by the Fetch spec
102#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
103pub struct Response {
104    pub response_type: ResponseType,
105    pub termination_reason: Option<TerminationReason>,
106    url: Option<ServoUrl>,
107    pub url_list: Vec<ServoUrl>,
108    pub status: HttpStatus,
109    #[serde(
110        deserialize_with = "::hyper_serde::deserialize",
111        serialize_with = "::hyper_serde::serialize"
112    )]
113    #[ignore_malloc_size_of = "Defined in hyper"]
114    pub headers: HeaderMap,
115    #[conditional_malloc_size_of]
116    pub body: Arc<Mutex<ResponseBody>>,
117    pub cache_state: CacheState,
118    pub https_state: HttpsState,
119    pub tls_security_info: Option<TlsSecurityInfo>,
120    pub referrer: Option<ServoUrl>,
121    /// <https://fetch.spec.whatwg.org/#response-redirect-taint>
122    pub redirect_taint: RedirectTaint,
123    pub referrer_policy: ReferrerPolicy,
124    /// [CORS-exposed header-name list](https://fetch.spec.whatwg.org/#concept-response-cors-exposed-header-name-list)
125    pub cors_exposed_header_name_list: Vec<String>,
126    /// [Location URL](https://fetch.spec.whatwg.org/#concept-response-location-url)
127    pub location_url: Option<Result<ServoUrl, String>>,
128    /// [Internal response](https://fetch.spec.whatwg.org/#concept-internal-response), only used if the Response
129    /// is a filtered response
130    pub internal_response: Option<Box<Response>>,
131    /// whether or not to try to return the internal_response when asked for actual_response
132    pub return_internal: bool,
133    /// <https://fetch.spec.whatwg.org/#concept-response-aborted>
134    #[conditional_malloc_size_of]
135    pub aborted: Arc<AtomicBool>,
136    /// track network metrics
137    #[conditional_malloc_size_of]
138    pub resource_timing: Arc<Mutex<ResourceFetchTiming>>,
139
140    /// <https://fetch.spec.whatwg.org/#concept-response-range-requested-flag>
141    pub range_requested: bool,
142}
143
144impl Response {
145    pub fn new(url: ServoUrl, resource_timing: ResourceFetchTiming) -> Response {
146        Response {
147            response_type: ResponseType::Default,
148            termination_reason: None,
149            url: Some(url),
150            url_list: vec![],
151            status: HttpStatus::default(),
152            headers: HeaderMap::new(),
153            body: Arc::new(Mutex::new(ResponseBody::Empty)),
154            cache_state: CacheState::None,
155            https_state: HttpsState::None,
156            tls_security_info: None,
157            referrer: None,
158            referrer_policy: ReferrerPolicy::EmptyString,
159            cors_exposed_header_name_list: vec![],
160            location_url: None,
161            internal_response: None,
162            return_internal: true,
163            aborted: Arc::new(AtomicBool::new(false)),
164            resource_timing: Arc::new(Mutex::new(resource_timing)),
165            range_requested: false,
166            redirect_taint: Default::default(),
167        }
168    }
169
170    pub fn from_init(init: ResponseInit, resource_timing_type: ResourceTimingType) -> Response {
171        let mut res = Response::new(init.url, ResourceFetchTiming::new(resource_timing_type));
172        res.location_url = init.location_url;
173        res.headers = init.headers;
174        res.referrer = init.referrer;
175        res.status = HttpStatus::new_raw(init.status_code, vec![]);
176        res
177    }
178
179    pub fn network_error(e: NetworkError) -> Response {
180        Response {
181            response_type: ResponseType::Error(e),
182            termination_reason: None,
183            url: None,
184            url_list: vec![],
185            status: HttpStatus::new_error(),
186            headers: HeaderMap::new(),
187            body: Arc::new(Mutex::new(ResponseBody::Empty)),
188            cache_state: CacheState::None,
189            https_state: HttpsState::None,
190            tls_security_info: None,
191            referrer: None,
192            referrer_policy: ReferrerPolicy::EmptyString,
193            cors_exposed_header_name_list: vec![],
194            location_url: None,
195            internal_response: None,
196            return_internal: true,
197            aborted: Arc::new(AtomicBool::new(false)),
198            resource_timing: Arc::new(Mutex::new(ResourceFetchTiming::new(
199                ResourceTimingType::Error,
200            ))),
201            range_requested: false,
202            redirect_taint: Default::default(),
203        }
204    }
205
206    pub fn url(&self) -> Option<&ServoUrl> {
207        self.url.as_ref()
208    }
209
210    pub fn is_network_error(&self) -> bool {
211        matches!(self.response_type, ResponseType::Error(..))
212    }
213
214    pub fn get_network_error(&self) -> Option<&NetworkError> {
215        match self.response_type {
216            ResponseType::Error(ref e) => Some(e),
217            _ => None,
218        }
219    }
220
221    pub fn set_network_error(&mut self, network_error: NetworkError) {
222        self.response_type = ResponseType::Error(network_error);
223    }
224
225    pub fn actual_response(&self) -> &Response {
226        if self.return_internal && self.internal_response.is_some() {
227            self.internal_response.as_ref().unwrap()
228        } else {
229            self
230        }
231    }
232
233    pub fn actual_response_mut(&mut self) -> &mut Response {
234        if self.return_internal && self.internal_response.is_some() {
235            self.internal_response.as_mut().unwrap()
236        } else {
237            self
238        }
239    }
240
241    pub fn to_actual(self) -> Response {
242        if self.return_internal && self.internal_response.is_some() {
243            *self.internal_response.unwrap()
244        } else {
245            self
246        }
247    }
248
249    pub fn get_resource_timing(&self) -> Arc<Mutex<ResourceFetchTiming>> {
250        Arc::clone(&self.resource_timing)
251    }
252
253    /// Convert to a filtered response, of type `filter_type`.
254    /// Do not use with type Error or Default
255    #[rustfmt::skip]
256    pub fn to_filtered(self, filter_type: ResponseType) -> Response {
257        match filter_type {
258            ResponseType::Default |
259            ResponseType::Error(..) => panic!(),
260            _ => (),
261        }
262
263        let old_response = self.to_actual();
264
265        if let ResponseType::Error(e) = old_response.response_type {
266            return Response::network_error(e);
267        }
268
269        let old_headers = old_response.headers.clone();
270        let exposed_headers = old_response.cors_exposed_header_name_list.clone();
271        let mut response = old_response.clone();
272        response.internal_response = Some(Box::new(old_response));
273        response.response_type = filter_type;
274
275        match response.response_type {
276            ResponseType::Default |
277            ResponseType::Error(..) => unreachable!(),
278
279            ResponseType::Basic => {
280                let headers = old_headers.iter().filter(|(name, _)| {
281                    !matches!(&*name.as_str().to_ascii_lowercase(), "set-cookie" | "set-cookie2")
282                }).map(|(n, v)| (n.clone(), v.clone())).collect();
283                response.headers = headers;
284            },
285
286            ResponseType::Cors => {
287                let headers = old_headers.iter().filter(|(name, _)| {
288                    match &*name.as_str().to_ascii_lowercase() {
289                        "cache-control" | "content-language" | "content-length" | "content-type" |
290                        "expires" | "last-modified" | "pragma" => true,
291                        "set-cookie" | "set-cookie2" => false,
292                        header => {
293                            exposed_headers.iter().any(|h| *header == h.as_str().to_ascii_lowercase())
294                        }
295                    }
296                }).map(|(n, v)| (n.clone(), v.clone())).collect();
297                response.headers = headers;
298            },
299
300            ResponseType::Opaque => {
301                response.url_list = vec![];
302                response.url = None;
303                response.headers = HeaderMap::new();
304                response.status = HttpStatus::new_error();
305                response.body = Arc::new(Mutex::new(ResponseBody::Empty));
306                response.cache_state = CacheState::None;
307            },
308
309            ResponseType::OpaqueRedirect => {
310                response.headers = HeaderMap::new();
311                response.status = HttpStatus::new_error();
312                response.body = Arc::new(Mutex::new(ResponseBody::Empty));
313                response.cache_state = CacheState::None;
314            },
315        }
316
317        response
318    }
319
320    pub fn metadata(&self) -> Result<FetchMetadata, NetworkError> {
321        fn init_metadata(response: &Response, url: &ServoUrl) -> Metadata {
322            let mut metadata = Metadata::default(url.clone());
323            metadata.set_content_type(extract_mime_type_as_mime(&response.headers).as_ref());
324            metadata.location_url.clone_from(&response.location_url);
325            metadata.headers = Some(Serde(response.headers.clone()));
326            metadata.status.clone_from(&response.status);
327            metadata.https_state = response.https_state;
328            metadata.referrer.clone_from(&response.referrer);
329            metadata.referrer_policy = response.referrer_policy;
330            metadata.redirected = response.actual_response().url_list.len() > 1;
331            metadata
332                .tls_security_info
333                .clone_from(&response.tls_security_info);
334            metadata
335        }
336
337        if let Some(error) = self.get_network_error() {
338            return Err(error.clone());
339        }
340
341        let metadata = self.url.as_ref().map(|url| init_metadata(self, url));
342
343        if let Some(ref response) = self.internal_response {
344            match response.url {
345                Some(ref url) => {
346                    let unsafe_metadata = init_metadata(response, url);
347
348                    match self.response_type {
349                        ResponseType::Basic => Ok(FetchMetadata::Filtered {
350                            filtered: FilteredMetadata::Basic(metadata.unwrap()),
351                            unsafe_: unsafe_metadata,
352                        }),
353                        ResponseType::Cors => Ok(FetchMetadata::Filtered {
354                            filtered: FilteredMetadata::Cors(metadata.unwrap()),
355                            unsafe_: unsafe_metadata,
356                        }),
357                        ResponseType::Default => unreachable!(),
358                        ResponseType::Error(ref network_err) => Err(network_err.clone()),
359                        ResponseType::Opaque => Ok(FetchMetadata::Filtered {
360                            filtered: FilteredMetadata::Opaque,
361                            unsafe_: unsafe_metadata,
362                        }),
363                        ResponseType::OpaqueRedirect => Ok(FetchMetadata::Filtered {
364                            filtered: FilteredMetadata::OpaqueRedirect(url.clone()),
365                            unsafe_: unsafe_metadata,
366                        }),
367                    }
368                },
369                None => Err(NetworkError::ResourceLoadError(
370                    "No url found in unsafe response".to_owned(),
371                )),
372            }
373        } else {
374            assert_eq!(self.response_type, ResponseType::Default);
375            Ok(FetchMetadata::Unfiltered(metadata.unwrap()))
376        }
377    }
378}
net_traits/response.rs

net_traits/
response.rs
