net_traits/
request.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
5use std::sync::Arc;
6
7use content_security_policy::{self as csp};
8use http::header::{AUTHORIZATION, HeaderName};
9use http::{HeaderMap, Method};
10use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
11use ipc_channel::router::ROUTER;
12use log::error;
13use malloc_size_of_derive::MallocSizeOf;
14use mime::Mime;
15use parking_lot::Mutex;
16use rustc_hash::FxHashMap;
17use serde::{Deserialize, Serialize};
18use servo_base::generic_channel::GenericSharedMemory;
19use servo_base::id::{PipelineId, WebViewId};
20use servo_url::{ImmutableOrigin, ServoUrl};
21use tokio::sync::oneshot::Sender as TokioSender;
22use url::Position;
23use uuid::Uuid;
24
25use crate::blob_url_store::UrlWithBlobClaim;
26use crate::policy_container::{PolicyContainer, RequestPolicyContainer};
27use crate::pub_domains::is_same_site;
28use crate::response::{HttpsState, RedirectTaint, Response};
29use crate::{ReferrerPolicy, ResourceTimingType};
30
31#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
32/// An id to differentiate one network request from another.
33pub struct RequestId(pub Uuid);
34
35impl Default for RequestId {
36    fn default() -> Self {
37        Self(Uuid::new_v4())
38    }
39}
40
41/// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator)
42#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
43pub enum Initiator {
44    None,
45    Download,
46    ImageSet,
47    Manifest,
48    XSLT,
49    Prefetch,
50    Link,
51}
52
53/// A request [destination](https://fetch.spec.whatwg.org/#concept-request-destination)
54pub use csp::Destination;
55
56/// A request [origin](https://fetch.spec.whatwg.org/#concept-request-origin)
57#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
58pub enum Origin {
59    Client,
60    Origin(ImmutableOrigin),
61}
62
63impl Origin {
64    pub fn is_opaque(&self) -> bool {
65        matches!(self, Origin::Origin(ImmutableOrigin::Opaque(_)))
66    }
67}
68
69/// A [referer](https://fetch.spec.whatwg.org/#concept-request-referrer)
70#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
71pub enum Referrer {
72    NoReferrer,
73    /// Contains the url that "client" would be resolved to. See
74    /// [https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer](https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer)
75    ///
76    /// If you are unsure you should probably use
77    /// [`GlobalScope::get_referrer`](https://doc.servo.org/script/dom/globalscope/struct.GlobalScope.html#method.get_referrer)
78    Client(ServoUrl),
79    ReferrerUrl(ServoUrl),
80}
81
82/// A [request mode](https://fetch.spec.whatwg.org/#concept-request-mode)
83#[derive(Clone, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
84pub enum RequestMode {
85    Navigate,
86    SameOrigin,
87    NoCors,
88    CorsMode,
89    WebSocket {
90        protocols: Vec<String>,
91        original_url: ServoUrl,
92    },
93}
94
95/// Request [credentials mode](https://fetch.spec.whatwg.org/#concept-request-credentials-mode)
96#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
97pub enum CredentialsMode {
98    Omit,
99    CredentialsSameOrigin,
100    Include,
101}
102
103/// [Cache mode](https://fetch.spec.whatwg.org/#concept-request-cache-mode)
104#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
105pub enum CacheMode {
106    Default,
107    NoStore,
108    Reload,
109    NoCache,
110    ForceCache,
111    OnlyIfCached,
112}
113
114/// [Service-workers mode](https://fetch.spec.whatwg.org/#request-service-workers-mode)
115#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
116pub enum ServiceWorkersMode {
117    All,
118    None,
119}
120
121/// [Redirect mode](https://fetch.spec.whatwg.org/#concept-request-redirect-mode)
122#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
123pub enum RedirectMode {
124    Follow,
125    Error,
126    Manual,
127}
128
129/// [Response tainting](https://fetch.spec.whatwg.org/#concept-request-response-tainting)
130#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
131pub enum ResponseTainting {
132    Basic,
133    CorsTainting,
134    Opaque,
135}
136
137/// <https://html.spec.whatwg.org/multipage/#preload-key>
138#[derive(Clone, Debug, Eq, Hash, Deserialize, MallocSizeOf, Serialize, PartialEq)]
139pub struct PreloadKey {
140    /// <https://html.spec.whatwg.org/multipage/#preload-url>
141    pub url: ServoUrl,
142    /// <https://html.spec.whatwg.org/multipage/#preload-destination>
143    pub destination: Destination,
144    /// <https://html.spec.whatwg.org/multipage/#preload-mode>
145    pub mode: RequestMode,
146    /// <https://html.spec.whatwg.org/multipage/#preload-credentials-mode>
147    pub credentials_mode: CredentialsMode,
148}
149
150impl PreloadKey {
151    pub fn new(request: &RequestBuilder) -> Self {
152        Self {
153            url: request.url.url(),
154            destination: request.destination,
155            mode: request.mode.clone(),
156            credentials_mode: request.credentials_mode,
157        }
158    }
159}
160
161#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize, Hash, MallocSizeOf)]
162pub struct PreloadId(pub Uuid);
163
164impl Default for PreloadId {
165    fn default() -> Self {
166        Self(Uuid::new_v4())
167    }
168}
169
170/// <https://html.spec.whatwg.org/multipage/#preload-entry>
171#[derive(Debug, MallocSizeOf)]
172pub struct PreloadEntry {
173    /// <https://html.spec.whatwg.org/multipage/#preload-integrity-metadata>
174    pub integrity_metadata: String,
175    /// <https://html.spec.whatwg.org/multipage/#preload-response>
176    pub response: Option<Response>,
177    /// <https://html.spec.whatwg.org/multipage/#preload-on-response-available>
178    pub on_response_available: Option<TokioSender<Response>>,
179}
180
181impl PreloadEntry {
182    pub fn new(integrity_metadata: String) -> Self {
183        Self {
184            integrity_metadata,
185            response: None,
186            on_response_available: None,
187        }
188    }
189
190    /// Part of step 11.5 of <https://html.spec.whatwg.org/multipage/#preload>
191    pub fn with_response(&mut self, response: Response) {
192        // Step 11.5. If entry's on response available is null, then set entry's response to response;
193        // otherwise call entry's on response available given response.
194        if let Some(sender) = self.on_response_available.take() {
195            let _ = sender.send(response);
196        } else {
197            self.response = Some(response);
198        }
199    }
200}
201
202pub type PreloadedResources = FxHashMap<PreloadKey, PreloadId>;
203
204/// <https://fetch.spec.whatwg.org/#concept-request-client>
205#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
206pub struct RequestClient {
207    /// <https://html.spec.whatwg.org/multipage/#map-of-preloaded-resources>
208    pub preloaded_resources: PreloadedResources,
209    /// <https://html.spec.whatwg.org/multipage/#concept-settings-object-policy-container>
210    pub policy_container: RequestPolicyContainer,
211    /// <https://html.spec.whatwg.org/multipage/#concept-settings-object-origin>
212    pub origin: Origin,
213    /// <https://html.spec.whatwg.org/multipage/#nested-browsing-context>
214    pub is_nested_browsing_context: bool,
215    /// <https://w3c.github.io/webappsec-upgrade-insecure-requests/#insecure-requests-policy>
216    pub insecure_requests_policy: InsecureRequestsPolicy,
217}
218
219/// <https://html.spec.whatwg.org/multipage/#system-visibility-state>
220#[derive(Clone, Copy, Default, MallocSizeOf, PartialEq)]
221pub enum SystemVisibilityState {
222    #[default]
223    Hidden,
224    Visible,
225}
226
227/// <https://html.spec.whatwg.org/multipage/#traversable-navigable>
228#[derive(Clone, Copy, Default, MallocSizeOf, PartialEq)]
229pub struct TraversableNavigable {
230    /// <https://html.spec.whatwg.org/multipage/#tn-current-session-history-step>
231    current_session_history_step: u8,
232    // TODO: https://html.spec.whatwg.org/multipage/#tn-session-history-entries
233    // TODO: https://html.spec.whatwg.org/multipage/#tn-session-history-traversal-queue
234    /// <https://html.spec.whatwg.org/multipage/#tn-running-nested-apply-history-step>
235    running_nested_apply_history_step: bool,
236    /// <https://html.spec.whatwg.org/multipage/#system-visibility-state>
237    system_visibility_state: SystemVisibilityState,
238    /// <https://html.spec.whatwg.org/multipage/#is-created-by-web-content>
239    is_created_by_web_content: bool,
240}
241
242/// <https://fetch.spec.whatwg.org/#concept-request-window>
243#[derive(Clone, Copy, MallocSizeOf, PartialEq)]
244pub enum TraversableForUserPrompts {
245    NoTraversable,
246    Client,
247    TraversableNavigable(TraversableNavigable),
248}
249
250/// [CORS settings attribute](https://html.spec.whatwg.org/multipage/#attr-crossorigin-anonymous)
251#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
252pub enum CorsSettings {
253    Anonymous,
254    UseCredentials,
255}
256
257impl CorsSettings {
258    /// <https://html.spec.whatwg.org/multipage/#cors-settings-attribute>
259    pub fn from_enumerated_attribute(value: &str) -> CorsSettings {
260        match value.to_ascii_lowercase().as_str() {
261            "anonymous" => CorsSettings::Anonymous,
262            "use-credentials" => CorsSettings::UseCredentials,
263            _ => CorsSettings::Anonymous,
264        }
265    }
266}
267
268/// [Parser Metadata](https://fetch.spec.whatwg.org/#concept-request-parser-metadata)
269#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
270pub enum ParserMetadata {
271    Default,
272    ParserInserted,
273    NotParserInserted,
274}
275
276/// <https://fetch.spec.whatwg.org/#concept-body-source>
277#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
278pub enum BodySource {
279    Null,
280    Object,
281}
282
283/// Messages used to implement <https://fetch.spec.whatwg.org/#concept-request-transmit-body>
284/// which are sent from script to net.
285#[derive(Debug, Deserialize, Serialize)]
286pub enum BodyChunkResponse {
287    /// A chunk of bytes.
288    Chunk(GenericSharedMemory),
289    /// The body is done.
290    Done,
291    /// There was an error streaming the body,
292    /// terminate fetch.
293    Error,
294}
295
296/// Messages used to implement <https://fetch.spec.whatwg.org/#concept-request-transmit-body>
297/// which are sent from net to script
298/// (with the exception of Done, which is sent from script to script).
299#[derive(Debug, Deserialize, Serialize)]
300pub enum BodyChunkRequest {
301    /// Connect a fetch in `net`, with a stream of bytes from `script`.
302    Connect(IpcSender<BodyChunkResponse>),
303    /// Re-extract a new stream from the source, following a redirect.
304    Extract(IpcReceiver<BodyChunkRequest>),
305    /// Ask for another chunk.
306    Chunk,
307    /// Signal the stream is done(sent from script to script).
308    Done,
309    /// Signal the stream has errored(sent from script to script).
310    Error,
311}
312
313/// A process local view into <https://fetch.spec.whatwg.org/#bodies>.
314/// After IPC serialization, each process gets its own shared sender state for the same body
315/// stream. the net side fetch entry points own clearing their local copy once that fetch invocation
316/// reaches its terminal state. Redirect replay can later deserialize a fresh "RequestBody", so
317/// lower level fetch steps cannot always clean up immediately.
318#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
319pub struct RequestBody {
320    /// Net's channel to communicate with script re this body.
321    #[conditional_malloc_size_of]
322    body_chunk_request_channel: Arc<Mutex<Option<IpcSender<BodyChunkRequest>>>>,
323    /// <https://fetch.spec.whatwg.org/#concept-body-source>
324    source: BodySource,
325    /// <https://fetch.spec.whatwg.org/#concept-body-total-bytes>
326    total_bytes: Option<usize>,
327}
328
329impl RequestBody {
330    pub fn new(
331        body_chunk_request_channel: IpcSender<BodyChunkRequest>,
332        source: BodySource,
333        total_bytes: Option<usize>,
334    ) -> Self {
335        RequestBody {
336            body_chunk_request_channel: Arc::new(Mutex::new(Some(body_chunk_request_channel))),
337            source,
338            total_bytes,
339        }
340    }
341
342    /// Step 12 of <https://fetch.spec.whatwg.org/#concept-http-redirect-fetch>
343    pub fn extract_source(&mut self) {
344        match self.source {
345            BodySource::Null => panic!("Null sources should never be re-directed."),
346            BodySource::Object => {
347                let (chan, port) = ipc::channel().unwrap();
348                let mut lock = self.body_chunk_request_channel.lock();
349                let Some(selfchan) = lock.as_mut() else {
350                    error!(
351                        "Could not re-extract the request body source because the body stream has already been closed."
352                    );
353                    return;
354                };
355                if let Err(error) = selfchan.send(BodyChunkRequest::Extract(port)) {
356                    error!(
357                        "Could not re-extract the request body source because the body stream has already been closed: {error}"
358                    );
359                    return;
360                }
361                *selfchan = chan;
362            },
363        }
364    }
365
366    /// This is the current process shared optional sender for requesting body chunks.
367    pub fn clone_stream(&self) -> Arc<Mutex<Option<IpcSender<BodyChunkRequest>>>> {
368        self.body_chunk_request_channel.clone()
369    }
370
371    /// Clears the current process shared sender state for this "RequestBody" copy.
372    ///
373    /// This does not notify or mutate other deserialized "RequestBody" values in other processes.
374    /// Can be called multiple times.
375    pub fn close_stream(&self) {
376        self.body_chunk_request_channel.lock().take();
377    }
378
379    pub fn source_is_null(&self) -> bool {
380        self.source == BodySource::Null
381    }
382
383    #[expect(clippy::len_without_is_empty)]
384    pub fn len(&self) -> Option<usize> {
385        self.total_bytes
386    }
387}
388
389trait RequestBodySize {
390    fn body_length(&self) -> usize;
391}
392
393impl RequestBodySize for Option<RequestBody> {
394    fn body_length(&self) -> usize {
395        self.as_ref()
396            .and_then(|body| body.len())
397            .unwrap_or_default()
398    }
399}
400
401#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
402pub enum InsecureRequestsPolicy {
403    DoNotUpgrade,
404    Upgrade,
405}
406
407pub trait RequestHeadersSize {
408    fn total_size(&self) -> usize;
409}
410
411impl RequestHeadersSize for HeaderMap {
412    fn total_size(&self) -> usize {
413        self.iter()
414            .map(|(name, value)| name.as_str().len() + value.len())
415            .sum()
416    }
417}
418
419#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
420pub struct RequestBuilder {
421    pub id: RequestId,
422
423    pub preload_id: Option<PreloadId>,
424
425    /// <https://fetch.spec.whatwg.org/#concept-request-method>
426    #[serde(
427        deserialize_with = "::hyper_serde::deserialize",
428        serialize_with = "::hyper_serde::serialize"
429    )]
430    pub method: Method,
431
432    /// <https://fetch.spec.whatwg.org/#concept-request-url>
433    pub url: UrlWithBlobClaim,
434
435    /// <https://fetch.spec.whatwg.org/#concept-request-header-list>
436    #[serde(
437        deserialize_with = "::hyper_serde::deserialize",
438        serialize_with = "::hyper_serde::serialize"
439    )]
440    pub headers: HeaderMap,
441
442    /// <https://fetch.spec.whatwg.org/#unsafe-request-flag>
443    pub unsafe_request: bool,
444
445    /// <https://fetch.spec.whatwg.org/#concept-request-body>
446    pub body: Option<RequestBody>,
447
448    /// <https://fetch.spec.whatwg.org/#request-service-workers-mode>
449    pub service_workers_mode: ServiceWorkersMode,
450    pub client: Option<RequestClient>,
451    /// <https://fetch.spec.whatwg.org/#concept-request-destination>
452    pub destination: Destination,
453    pub synchronous: bool,
454    pub mode: RequestMode,
455
456    /// <https://fetch.spec.whatwg.org/#concept-request-cache-mode>
457    pub cache_mode: CacheMode,
458
459    /// <https://fetch.spec.whatwg.org/#use-cors-preflight-flag>
460    pub use_cors_preflight: bool,
461
462    /// <https://fetch.spec.whatwg.org/#request-keepalive-flag>
463    pub keep_alive: bool,
464
465    /// <https://fetch.spec.whatwg.org/#concept-request-credentials-mode>
466    pub credentials_mode: CredentialsMode,
467    pub use_url_credentials: bool,
468
469    /// <https://fetch.spec.whatwg.org/#concept-request-origin>
470    pub origin: Origin,
471
472    /// <https://fetch.spec.whatwg.org/#concept-request-policy-container>
473    pub policy_container: RequestPolicyContainer,
474    pub insecure_requests_policy: InsecureRequestsPolicy,
475    pub has_trustworthy_ancestor_origin: bool,
476
477    /// <https://fetch.spec.whatwg.org/#concept-request-referrer>
478    pub referrer: Referrer,
479
480    /// <https://fetch.spec.whatwg.org/#concept-request-referrer-policy>
481    pub referrer_policy: ReferrerPolicy,
482    pub pipeline_id: Option<PipelineId>,
483    pub target_webview_id: Option<WebViewId>,
484
485    /// <https://fetch.spec.whatwg.org/#concept-request-redirect-mode>
486    pub redirect_mode: RedirectMode,
487
488    /// <https://fetch.spec.whatwg.org/#concept-request-integrity-metadata>
489    pub integrity_metadata: String,
490
491    /// <https://fetch.spec.whatwg.org/#concept-request-nonce-metadata>
492    pub cryptographic_nonce_metadata: String,
493
494    /// <https://fetch.spec.whatwg.org/#concept-request-url-list>
495    pub url_list: Vec<ServoUrl>,
496
497    /// <https://fetch.spec.whatwg.org/#concept-request-parser-metadata>
498    pub parser_metadata: ParserMetadata,
499
500    /// <https://fetch.spec.whatwg.org/#concept-request-initiator>
501    pub initiator: Initiator,
502    pub https_state: HttpsState,
503    pub response_tainting: ResponseTainting,
504    /// Servo internal: if crash details are present, trigger a crash error page with these details.
505    pub crash: Option<String>,
506}
507
508impl RequestBuilder {
509    pub fn new(
510        webview_id: Option<WebViewId>,
511        url: UrlWithBlobClaim,
512        referrer: Referrer,
513    ) -> RequestBuilder {
514        RequestBuilder {
515            id: RequestId::default(),
516            preload_id: None,
517            method: Method::GET,
518            url,
519            headers: HeaderMap::new(),
520            unsafe_request: false,
521            body: None,
522            service_workers_mode: ServiceWorkersMode::All,
523            destination: Destination::None,
524            synchronous: false,
525            mode: RequestMode::NoCors,
526            cache_mode: CacheMode::Default,
527            use_cors_preflight: false,
528            keep_alive: false,
529            credentials_mode: CredentialsMode::CredentialsSameOrigin,
530            use_url_credentials: false,
531            origin: Origin::Client,
532            client: None,
533            policy_container: RequestPolicyContainer::default(),
534            insecure_requests_policy: InsecureRequestsPolicy::DoNotUpgrade,
535            has_trustworthy_ancestor_origin: false,
536            referrer,
537            referrer_policy: ReferrerPolicy::EmptyString,
538            pipeline_id: None,
539            target_webview_id: webview_id,
540            redirect_mode: RedirectMode::Follow,
541            integrity_metadata: "".to_owned(),
542            cryptographic_nonce_metadata: "".to_owned(),
543            url_list: vec![],
544            parser_metadata: ParserMetadata::Default,
545            initiator: Initiator::None,
546            https_state: HttpsState::None,
547            response_tainting: ResponseTainting::Basic,
548            crash: None,
549        }
550    }
551
552    pub fn preload_id(mut self, preload_id: PreloadId) -> RequestBuilder {
553        self.preload_id = Some(preload_id);
554        self
555    }
556
557    /// <https://fetch.spec.whatwg.org/#concept-request-initiator>
558    pub fn initiator(mut self, initiator: Initiator) -> RequestBuilder {
559        self.initiator = initiator;
560        self
561    }
562
563    /// <https://fetch.spec.whatwg.org/#concept-request-method>
564    pub fn method(mut self, method: Method) -> RequestBuilder {
565        self.method = method;
566        self
567    }
568
569    /// <https://fetch.spec.whatwg.org/#concept-request-header-list>
570    pub fn headers(mut self, headers: HeaderMap) -> RequestBuilder {
571        self.headers = headers;
572        self
573    }
574
575    /// <https://fetch.spec.whatwg.org/#unsafe-request-flag>
576    pub fn unsafe_request(mut self, unsafe_request: bool) -> RequestBuilder {
577        self.unsafe_request = unsafe_request;
578        self
579    }
580
581    /// <https://fetch.spec.whatwg.org/#concept-request-body>
582    pub fn body(mut self, body: Option<RequestBody>) -> RequestBuilder {
583        self.body = body;
584        self
585    }
586
587    /// <https://fetch.spec.whatwg.org/#concept-request-destination>
588    pub fn destination(mut self, destination: Destination) -> RequestBuilder {
589        self.destination = destination;
590        self
591    }
592
593    pub fn synchronous(mut self, synchronous: bool) -> RequestBuilder {
594        self.synchronous = synchronous;
595        self
596    }
597
598    pub fn mode(mut self, mode: RequestMode) -> RequestBuilder {
599        self.mode = mode;
600        self
601    }
602
603    /// <https://fetch.spec.whatwg.org/#use-cors-preflight-flag>
604    pub fn use_cors_preflight(mut self, use_cors_preflight: bool) -> RequestBuilder {
605        self.use_cors_preflight = use_cors_preflight;
606        self
607    }
608
609    /// <https://fetch.spec.whatwg.org/#request-keepalive-flag>
610    pub fn keep_alive(mut self, keep_alive: bool) -> RequestBuilder {
611        self.keep_alive = keep_alive;
612        self
613    }
614
615    /// <https://fetch.spec.whatwg.org/#concept-request-credentials-mode>
616    pub fn credentials_mode(mut self, credentials_mode: CredentialsMode) -> RequestBuilder {
617        self.credentials_mode = credentials_mode;
618        self
619    }
620
621    pub fn use_url_credentials(mut self, use_url_credentials: bool) -> RequestBuilder {
622        self.use_url_credentials = use_url_credentials;
623        self
624    }
625
626    /// <https://fetch.spec.whatwg.org/#concept-request-origin>
627    pub fn origin(mut self, origin: ImmutableOrigin) -> RequestBuilder {
628        self.origin = Origin::Origin(origin);
629        self
630    }
631
632    /// <https://fetch.spec.whatwg.org/#concept-request-referrer-policy>
633    pub fn referrer_policy(mut self, referrer_policy: ReferrerPolicy) -> RequestBuilder {
634        self.referrer_policy = referrer_policy;
635        self
636    }
637
638    /// <https://fetch.spec.whatwg.org/#concept-request-url-list>
639    pub fn url_list(mut self, url_list: Vec<ServoUrl>) -> RequestBuilder {
640        self.url_list = url_list;
641        self
642    }
643
644    pub fn pipeline_id(mut self, pipeline_id: Option<PipelineId>) -> RequestBuilder {
645        self.pipeline_id = pipeline_id;
646        self
647    }
648
649    /// <https://fetch.spec.whatwg.org/#concept-request-redirect-mode>
650    pub fn redirect_mode(mut self, redirect_mode: RedirectMode) -> RequestBuilder {
651        self.redirect_mode = redirect_mode;
652        self
653    }
654
655    /// <https://fetch.spec.whatwg.org/#concept-request-integrity-metadata>
656    pub fn integrity_metadata(mut self, integrity_metadata: String) -> RequestBuilder {
657        self.integrity_metadata = integrity_metadata;
658        self
659    }
660
661    /// <https://fetch.spec.whatwg.org/#concept-request-nonce-metadata>
662    pub fn cryptographic_nonce_metadata(mut self, nonce_metadata: String) -> RequestBuilder {
663        self.cryptographic_nonce_metadata = nonce_metadata;
664        self
665    }
666
667    /// <https://fetch.spec.whatwg.org/#concept-request-parser-metadata>
668    pub fn parser_metadata(mut self, parser_metadata: ParserMetadata) -> RequestBuilder {
669        self.parser_metadata = parser_metadata;
670        self
671    }
672
673    pub fn https_state(mut self, https_state: HttpsState) -> RequestBuilder {
674        self.https_state = https_state;
675        self
676    }
677
678    pub fn response_tainting(mut self, response_tainting: ResponseTainting) -> RequestBuilder {
679        self.response_tainting = response_tainting;
680        self
681    }
682
683    pub fn crash(mut self, crash: Option<String>) -> Self {
684        self.crash = crash;
685        self
686    }
687
688    /// <https://fetch.spec.whatwg.org/#concept-request-policy-container>
689    pub fn policy_container(mut self, policy_container: PolicyContainer) -> RequestBuilder {
690        self.policy_container = RequestPolicyContainer::PolicyContainer(policy_container);
691        self
692    }
693
694    /// <https://fetch.spec.whatwg.org/#concept-request-client>
695    pub fn client(mut self, client: RequestClient) -> RequestBuilder {
696        self.client = Some(client);
697        self
698    }
699
700    pub fn insecure_requests_policy(
701        mut self,
702        insecure_requests_policy: InsecureRequestsPolicy,
703    ) -> RequestBuilder {
704        self.insecure_requests_policy = insecure_requests_policy;
705        self
706    }
707
708    pub fn has_trustworthy_ancestor_origin(
709        mut self,
710        has_trustworthy_ancestor_origin: bool,
711    ) -> RequestBuilder {
712        self.has_trustworthy_ancestor_origin = has_trustworthy_ancestor_origin;
713        self
714    }
715
716    /// <https://fetch.spec.whatwg.org/#request-service-workers-mode>
717    pub fn service_workers_mode(
718        mut self,
719        service_workers_mode: ServiceWorkersMode,
720    ) -> RequestBuilder {
721        self.service_workers_mode = service_workers_mode;
722        self
723    }
724
725    /// <https://fetch.spec.whatwg.org/#concept-request-cache-mode>
726    pub fn cache_mode(mut self, cache_mode: CacheMode) -> RequestBuilder {
727        self.cache_mode = cache_mode;
728        self
729    }
730
731    pub fn build(self) -> Request {
732        let mut request = Request::new(
733            self.id,
734            self.url.clone(),
735            Some(self.origin),
736            self.referrer,
737            self.pipeline_id,
738            self.target_webview_id,
739            self.https_state,
740        );
741        request.preload_id = self.preload_id;
742        request.initiator = self.initiator;
743        request.method = self.method;
744        request.headers = self.headers;
745        request.unsafe_request = self.unsafe_request;
746        request.body = self.body;
747        request.service_workers_mode = self.service_workers_mode;
748        request.destination = self.destination;
749        request.synchronous = self.synchronous;
750        request.mode = self.mode;
751        request.use_cors_preflight = self.use_cors_preflight;
752        request.keep_alive = self.keep_alive;
753        request.credentials_mode = self.credentials_mode;
754        request.use_url_credentials = self.use_url_credentials;
755        request.cache_mode = self.cache_mode;
756        request.referrer_policy = self.referrer_policy;
757        request.redirect_mode = self.redirect_mode;
758        let mut url_list: Vec<_> = self
759            .url_list
760            .into_iter()
761            .map(UrlWithBlobClaim::from_url_without_having_claimed_blob)
762            .collect();
763        if url_list.is_empty() {
764            url_list.push(self.url);
765        }
766        request.redirect_count = url_list.len() as u32 - 1;
767        request.url_list = url_list;
768        request.integrity_metadata = self.integrity_metadata;
769        request.cryptographic_nonce_metadata = self.cryptographic_nonce_metadata;
770        request.parser_metadata = self.parser_metadata;
771        request.response_tainting = self.response_tainting;
772        request.crash = self.crash;
773        request.client = self.client;
774        request.policy_container = self.policy_container;
775        request.insecure_requests_policy = self.insecure_requests_policy;
776        request.has_trustworthy_ancestor_origin = self.has_trustworthy_ancestor_origin;
777        request
778    }
779
780    /// The body length for a keep-alive request. Is 0 if this request is not keep-alive
781    pub fn keep_alive_body_length(&self) -> u64 {
782        assert!(self.keep_alive);
783        self.body.body_length() as u64
784    }
785}
786
787/// A [Request](https://fetch.spec.whatwg.org/#concept-request) as defined by
788/// the Fetch spec.
789#[derive(Clone, MallocSizeOf)]
790pub struct Request {
791    /// The unique id of this request so that the task that triggered it can route
792    /// messages to the correct listeners. This is a UUID that is generated when a request
793    /// is being built.
794    pub id: RequestId,
795    pub preload_id: Option<PreloadId>,
796    /// <https://fetch.spec.whatwg.org/#concept-request-method>
797    pub method: Method,
798    /// <https://fetch.spec.whatwg.org/#local-urls-only-flag>
799    pub local_urls_only: bool,
800    /// <https://fetch.spec.whatwg.org/#concept-request-header-list>
801    pub headers: HeaderMap,
802    /// <https://fetch.spec.whatwg.org/#unsafe-request-flag>
803    pub unsafe_request: bool,
804    /// <https://fetch.spec.whatwg.org/#concept-request-body>
805    pub body: Option<RequestBody>,
806    /// <https://fetch.spec.whatwg.org/#concept-request-client>
807    pub client: Option<RequestClient>,
808    /// <https://fetch.spec.whatwg.org/#concept-request-window>
809    pub traversable_for_user_prompts: TraversableForUserPrompts,
810    pub target_webview_id: Option<WebViewId>,
811    /// <https://fetch.spec.whatwg.org/#request-keepalive-flag>
812    pub keep_alive: bool,
813    /// <https://fetch.spec.whatwg.org/#request-service-workers-mode>
814    pub service_workers_mode: ServiceWorkersMode,
815    /// <https://fetch.spec.whatwg.org/#concept-request-initiator>
816    pub initiator: Initiator,
817    /// <https://fetch.spec.whatwg.org/#concept-request-destination>
818    pub destination: Destination,
819    // TODO: priority object
820    /// <https://fetch.spec.whatwg.org/#concept-request-origin>
821    pub origin: Origin,
822    /// <https://fetch.spec.whatwg.org/#concept-request-referrer>
823    pub referrer: Referrer,
824    /// <https://fetch.spec.whatwg.org/#concept-request-referrer-policy>
825    pub referrer_policy: ReferrerPolicy,
826    pub pipeline_id: Option<PipelineId>,
827    /// <https://fetch.spec.whatwg.org/#synchronous-flag>
828    pub synchronous: bool,
829    /// <https://fetch.spec.whatwg.org/#concept-request-mode>
830    pub mode: RequestMode,
831    /// <https://fetch.spec.whatwg.org/#use-cors-preflight-flag>
832    pub use_cors_preflight: bool,
833    /// <https://fetch.spec.whatwg.org/#concept-request-credentials-mode>
834    pub credentials_mode: CredentialsMode,
835    /// <https://fetch.spec.whatwg.org/#concept-request-use-url-credentials-flag>
836    pub use_url_credentials: bool,
837    /// <https://fetch.spec.whatwg.org/#concept-request-cache-mode>
838    pub cache_mode: CacheMode,
839    /// <https://fetch.spec.whatwg.org/#concept-request-redirect-mode>
840    pub redirect_mode: RedirectMode,
841    /// <https://fetch.spec.whatwg.org/#concept-request-integrity-metadata>
842    pub integrity_metadata: String,
843    /// <https://fetch.spec.whatwg.org/#concept-request-nonce-metadata>
844    pub cryptographic_nonce_metadata: String,
845    /// <https://fetch.spec.whatwg.org/#concept-request-url-list>
846    pub url_list: Vec<UrlWithBlobClaim>,
847    /// <https://fetch.spec.whatwg.org/#concept-request-redirect-count>
848    pub redirect_count: u32,
849    /// <https://fetch.spec.whatwg.org/#concept-request-response-tainting>
850    pub response_tainting: ResponseTainting,
851    /// <https://fetch.spec.whatwg.org/#concept-request-parser-metadata>
852    pub parser_metadata: ParserMetadata,
853    /// <https://fetch.spec.whatwg.org/#concept-request-policy-container>
854    pub policy_container: RequestPolicyContainer,
855    /// <https://w3c.github.io/webappsec-upgrade-insecure-requests/#insecure-requests-policy>
856    pub insecure_requests_policy: InsecureRequestsPolicy,
857    pub has_trustworthy_ancestor_origin: bool,
858    pub https_state: HttpsState,
859    /// Servo internal: if crash details are present, trigger a crash error page with these details.
860    pub crash: Option<String>,
861}
862
863impl Request {
864    pub fn new(
865        id: RequestId,
866        url: UrlWithBlobClaim,
867        origin: Option<Origin>,
868        referrer: Referrer,
869        pipeline_id: Option<PipelineId>,
870        webview_id: Option<WebViewId>,
871        https_state: HttpsState,
872    ) -> Request {
873        Request {
874            id,
875            preload_id: None,
876            method: Method::GET,
877            local_urls_only: false,
878            headers: HeaderMap::new(),
879            unsafe_request: false,
880            body: None,
881            client: None,
882            traversable_for_user_prompts: TraversableForUserPrompts::Client,
883            keep_alive: false,
884            service_workers_mode: ServiceWorkersMode::All,
885            initiator: Initiator::None,
886            destination: Destination::None,
887            origin: origin.unwrap_or(Origin::Client),
888            referrer,
889            referrer_policy: ReferrerPolicy::EmptyString,
890            pipeline_id,
891            target_webview_id: webview_id,
892            synchronous: false,
893            mode: RequestMode::NoCors,
894            use_cors_preflight: false,
895            credentials_mode: CredentialsMode::CredentialsSameOrigin,
896            use_url_credentials: false,
897            cache_mode: CacheMode::Default,
898            redirect_mode: RedirectMode::Follow,
899            integrity_metadata: String::new(),
900            cryptographic_nonce_metadata: String::new(),
901            url_list: vec![url],
902            parser_metadata: ParserMetadata::Default,
903            redirect_count: 0,
904            response_tainting: ResponseTainting::Basic,
905            policy_container: RequestPolicyContainer::Client,
906            insecure_requests_policy: InsecureRequestsPolicy::DoNotUpgrade,
907            has_trustworthy_ancestor_origin: false,
908            https_state,
909            crash: None,
910        }
911    }
912
913    /// <https://fetch.spec.whatwg.org/#concept-request-url>
914    pub fn url(&self) -> ServoUrl {
915        self.url_list.first().unwrap().url()
916    }
917
918    pub fn url_with_blob_claim(&self) -> UrlWithBlobClaim {
919        self.url_list.first().unwrap().clone()
920    }
921
922    pub fn original_url(&self) -> ServoUrl {
923        match self.mode {
924            RequestMode::WebSocket {
925                protocols: _,
926                ref original_url,
927            } => original_url.clone(),
928            _ => self.url(),
929        }
930    }
931
932    /// <https://fetch.spec.whatwg.org/#concept-request-current-url>
933    pub fn current_url(&self) -> ServoUrl {
934        self.current_url_with_blob_claim().url()
935    }
936
937    /// <https://fetch.spec.whatwg.org/#concept-request-current-url>
938    pub fn current_url_with_blob_claim(&self) -> UrlWithBlobClaim {
939        self.url_list.last().unwrap().clone()
940    }
941
942    /// <https://fetch.spec.whatwg.org/#concept-request-current-url>
943    pub fn current_url_mut(&mut self) -> &mut ServoUrl {
944        self.url_list.last_mut().unwrap()
945    }
946
947    /// <https://fetch.spec.whatwg.org/#navigation-request>
948    pub fn is_navigation_request(&self) -> bool {
949        matches!(
950            self.destination,
951            Destination::Document |
952                Destination::Embed |
953                Destination::Frame |
954                Destination::IFrame |
955                Destination::Object
956        )
957    }
958
959    /// <https://fetch.spec.whatwg.org/#subresource-request>
960    pub fn is_subresource_request(&self) -> bool {
961        matches!(
962            self.destination,
963            Destination::Audio |
964                Destination::Font |
965                Destination::Image |
966                Destination::Manifest |
967                Destination::Script |
968                Destination::Style |
969                Destination::Track |
970                Destination::Video |
971                Destination::Xslt |
972                Destination::None
973        )
974    }
975
976    pub fn timing_type(&self) -> ResourceTimingType {
977        if self.is_navigation_request() {
978            ResourceTimingType::Navigation
979        } else {
980            ResourceTimingType::Resource
981        }
982    }
983
984    /// <https://fetch.spec.whatwg.org/#populate-request-from-client>
985    pub fn populate_request_from_client(&mut self) {
986        // Step 1. If request’s traversable for user prompts is "client":
987        if self.traversable_for_user_prompts == TraversableForUserPrompts::Client {
988            // Step 1.1. Set request’s traversable for user prompts to "no-traversable".
989            self.traversable_for_user_prompts = TraversableForUserPrompts::NoTraversable;
990            // Step 1.2. If request’s client is non-null:
991            if self.client.is_some() {
992                // Step 1.2.1. Let global be request’s client’s global object.
993                // TODO
994                // Step 1.2.2. If global is a Window object and global’s navigable is not null,
995                // then set request’s traversable for user prompts to global’s navigable’s traversable navigable.
996                self.traversable_for_user_prompts =
997                    TraversableForUserPrompts::TraversableNavigable(Default::default());
998            }
999        }
1000        // Step 2. If request’s origin is "client":
1001        if self.origin == Origin::Client {
1002            let Some(client) = self.client.as_ref() else {
1003                // Step 2.1. Assert: request’s client is non-null.
1004                unreachable!();
1005            };
1006            // Step 2.2. Set request’s origin to request’s client’s origin.
1007            self.origin = client.origin.clone();
1008        }
1009        // Step 3. If request’s policy container is "client":
1010        if matches!(self.policy_container, RequestPolicyContainer::Client) {
1011            // Step 3.1. If request’s client is non-null, then set request’s
1012            // policy container to a clone of request’s client’s policy container. [HTML]
1013            if let Some(client) = self.client.as_ref() {
1014                self.policy_container = client.policy_container.clone();
1015            } else {
1016                // Step 3.2. Otherwise, set request’s policy container to a new policy container.
1017                self.policy_container =
1018                    RequestPolicyContainer::PolicyContainer(PolicyContainer::default());
1019            }
1020        }
1021    }
1022
1023    /// The body length for a keep-alive request. Is 0 if this request is not keep-alive
1024    pub fn keep_alive_body_length(&self) -> u64 {
1025        assert!(self.keep_alive);
1026        self.body.body_length() as u64
1027    }
1028
1029    /// <https://fetch.spec.whatwg.org/#total-request-length>
1030    pub fn total_request_length(&self) -> usize {
1031        // Step 1. Let totalRequestLength be the length of request’s URL, serialized with exclude fragment set to true.
1032        let mut total_request_length = self.url()[..Position::AfterQuery].len();
1033        // Step 2. Increment totalRequestLength by the length of request’s referrer, serialized.
1034        total_request_length += self
1035            .referrer
1036            .to_url()
1037            .map(|url| url.as_str().len())
1038            .unwrap_or_default();
1039        // Step 3. For each (name, value) of request’s header list, increment totalRequestLength
1040        // by name’s length + value’s length.
1041        total_request_length += self.headers.total_size();
1042        // Step 4. Increment totalRequestLength by request’s body’s length.
1043        total_request_length += self.body.body_length();
1044        // Step 5. Return totalRequestLength.
1045        total_request_length
1046    }
1047
1048    /// <https://fetch.spec.whatwg.org/#concept-request-tainted-origin>
1049    pub fn redirect_taint_for_request(&self) -> RedirectTaint {
1050        // Step 1. Assert: request’s origin is not "client".
1051        let Origin::Origin(request_origin) = &self.origin else {
1052            unreachable!("origin cannot be \"client\" at this point in time");
1053        };
1054
1055        // Step 2. Let lastURL be null.
1056        let mut last_url = None;
1057
1058        // Step 3. Let taint be "same-origin".
1059        let mut taint = RedirectTaint::SameOrigin;
1060
1061        // Step 4. For each url of request’s URL list:
1062        for url in &self.url_list {
1063            // Step 4.1 If lastURL is null, then set lastURL to url and continue.
1064            let Some(last_url) = &mut last_url else {
1065                last_url = Some(url);
1066                continue;
1067            };
1068
1069            // Step 4.2. If url’s origin is not same site with lastURL’s origin and
1070            // request’s origin is not same site with lastURL’s origin, then return "cross-site".
1071            if !is_same_site(&url.origin(), &last_url.origin()) &&
1072                !is_same_site(request_origin, &last_url.origin())
1073            {
1074                return RedirectTaint::CrossSite;
1075            }
1076
1077            // Step 4.3. If url’s origin is not same origin with lastURL’s origin
1078            // and request’s origin is not same origin with lastURL’s origin, then set taint to "same-site".
1079            if url.origin() != last_url.origin() && *request_origin != last_url.origin() {
1080                taint = RedirectTaint::SameSite;
1081            }
1082
1083            // Step 4.4 Set lastURL to url.
1084            *last_url = url;
1085        }
1086
1087        // Step 5. Return taint.
1088        taint
1089    }
1090}
1091
1092impl Referrer {
1093    pub fn to_url(&self) -> Option<&ServoUrl> {
1094        match *self {
1095            Referrer::NoReferrer => None,
1096            Referrer::Client(ref url) => Some(url),
1097            Referrer::ReferrerUrl(ref url) => Some(url),
1098        }
1099    }
1100}
1101
1102// https://fetch.spec.whatwg.org/#cors-unsafe-request-header-byte
1103// TODO: values in the control-code range are being quietly stripped out by
1104// HeaderMap and never reach this function to be loudly rejected!
1105fn is_cors_unsafe_request_header_byte(value: &u8) -> bool {
1106    matches!(value,
1107        0x00..=0x08 |
1108        0x10..=0x19 |
1109        0x22 |
1110        0x28 |
1111        0x29 |
1112        0x3A |
1113        0x3C |
1114        0x3E |
1115        0x3F |
1116        0x40 |
1117        0x5B |
1118        0x5C |
1119        0x5D |
1120        0x7B |
1121        0x7D |
1122        0x7F
1123    )
1124}
1125
1126// https://fetch.spec.whatwg.org/#cors-safelisted-request-header
1127// subclause `accept`
1128fn is_cors_safelisted_request_accept(value: &[u8]) -> bool {
1129    !(value.iter().any(is_cors_unsafe_request_header_byte))
1130}
1131
1132// https://fetch.spec.whatwg.org/#cors-safelisted-request-header
1133// subclauses `accept-language`, `content-language`
1134fn is_cors_safelisted_language(value: &[u8]) -> bool {
1135    value.iter().all(|&x| {
1136        matches!(x,
1137            0x30..=0x39 |
1138            0x41..=0x5A |
1139            0x61..=0x7A |
1140            0x20 |
1141            0x2A |
1142            0x2C |
1143            0x2D |
1144            0x2E |
1145            0x3B |
1146            0x3D
1147        )
1148    })
1149}
1150
1151// https://fetch.spec.whatwg.org/#cors-safelisted-request-header
1152// subclause `content-type`
1153pub fn is_cors_safelisted_request_content_type(value: &[u8]) -> bool {
1154    // step 1
1155    if value.iter().any(is_cors_unsafe_request_header_byte) {
1156        return false;
1157    }
1158    // step 2
1159    let value_string = if let Ok(s) = std::str::from_utf8(value) {
1160        s
1161    } else {
1162        return false;
1163    };
1164    let value_mime_result: Result<Mime, _> = value_string.parse();
1165    match value_mime_result {
1166        Err(_) => false, // step 3
1167        Ok(value_mime) => match (value_mime.type_(), value_mime.subtype()) {
1168            (mime::APPLICATION, mime::WWW_FORM_URLENCODED) |
1169            (mime::MULTIPART, mime::FORM_DATA) |
1170            (mime::TEXT, mime::PLAIN) => true,
1171            _ => false, // step 4
1172        },
1173    }
1174}
1175
1176// TODO: "DPR", "Downlink", "Save-Data", "Viewport-Width", "Width":
1177// ... once parsed, the value should not be failure.
1178// https://fetch.spec.whatwg.org/#cors-safelisted-request-header
1179pub fn is_cors_safelisted_request_header<N: AsRef<str>, V: AsRef<[u8]>>(
1180    name: &N,
1181    value: &V,
1182) -> bool {
1183    let name: &str = name.as_ref();
1184    let value: &[u8] = value.as_ref();
1185    if value.len() > 128 {
1186        return false;
1187    }
1188    match name {
1189        "accept" => is_cors_safelisted_request_accept(value),
1190        "accept-language" | "content-language" => is_cors_safelisted_language(value),
1191        "content-type" => is_cors_safelisted_request_content_type(value),
1192        "range" => is_cors_safelisted_request_range(value),
1193        _ => false,
1194    }
1195}
1196
1197pub fn is_cors_safelisted_request_range(value: &[u8]) -> bool {
1198    if let Ok(value_str) = std::str::from_utf8(value) {
1199        return validate_range_header(value_str);
1200    }
1201    false
1202}
1203
1204fn validate_range_header(value: &str) -> bool {
1205    let trimmed = value.trim();
1206    if !trimmed.starts_with("bytes=") {
1207        return false;
1208    }
1209
1210    if let Some(range) = trimmed.strip_prefix("bytes=") {
1211        let mut parts = range.split('-');
1212        let start = parts.next();
1213        let end = parts.next();
1214
1215        if let Some(start) = start {
1216            if let Ok(start_num) = start.parse::<u64>() {
1217                return match end {
1218                    Some(e) if !e.is_empty() => {
1219                        e.parse::<u64>().is_ok_and(|end_num| start_num <= end_num)
1220                    },
1221                    _ => true,
1222                };
1223            }
1224        }
1225    }
1226    false
1227}
1228
1229/// <https://fetch.spec.whatwg.org/#cors-safelisted-method>
1230pub fn is_cors_safelisted_method(method: &Method) -> bool {
1231    matches!(*method, Method::GET | Method::HEAD | Method::POST)
1232}
1233
1234/// <https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name>
1235pub fn is_cors_non_wildcard_request_header_name(name: &HeaderName) -> bool {
1236    name == AUTHORIZATION
1237}
1238
1239/// <https://fetch.spec.whatwg.org/#cors-unsafe-request-header-names>
1240pub fn get_cors_unsafe_header_names(headers: &HeaderMap) -> Vec<HeaderName> {
1241    // Step 1
1242    let mut unsafe_names: Vec<&HeaderName> = vec![];
1243    // Step 2
1244    let mut potentillay_unsafe_names: Vec<&HeaderName> = vec![];
1245    // Step 3
1246    let mut safelist_value_size = 0;
1247
1248    // Step 4
1249    for (name, value) in headers.iter() {
1250        if !is_cors_safelisted_request_header(&name, &value) {
1251            unsafe_names.push(name);
1252        } else {
1253            potentillay_unsafe_names.push(name);
1254            safelist_value_size += value.as_ref().len();
1255        }
1256    }
1257
1258    // Step 5
1259    if safelist_value_size > 1024 {
1260        unsafe_names.extend_from_slice(&potentillay_unsafe_names);
1261    }
1262
1263    // Step 6
1264    convert_header_names_to_sorted_lowercase_set(unsafe_names)
1265}
1266
1267/// <https://fetch.spec.whatwg.org/#ref-for-convert-header-names-to-a-sorted-lowercase-set>
1268pub fn convert_header_names_to_sorted_lowercase_set(
1269    header_names: Vec<&HeaderName>,
1270) -> Vec<HeaderName> {
1271    // HeaderName does not implement the needed traits to use a BTreeSet
1272    // So create a new Vec, sort, then dedup
1273    let mut ordered_set = header_names.to_vec();
1274    ordered_set.sort_by(|a, b| a.as_str().partial_cmp(b.as_str()).unwrap());
1275    ordered_set.dedup();
1276    ordered_set.into_iter().cloned().collect()
1277}
1278
1279pub fn create_request_body_with_content(content: &str) -> RequestBody {
1280    let content_bytes = GenericSharedMemory::from_bytes(content.as_bytes());
1281    let content_len = content_bytes.len();
1282
1283    let (chunk_request_sender, chunk_request_receiver) = ipc::channel().unwrap();
1284    ROUTER.add_typed_route(
1285        chunk_request_receiver,
1286        Box::new(move |message| {
1287            let request = message.unwrap();
1288            if let BodyChunkRequest::Connect(sender) = request {
1289                let _ = sender.send(BodyChunkResponse::Chunk(content_bytes.clone()));
1290                let _ = sender.send(BodyChunkResponse::Done);
1291            }
1292        }),
1293    );
1294
1295    RequestBody::new(chunk_request_sender, BodySource::Object, Some(content_len))
1296}
net_traits/request.rs

net_traits/
request.rs
