1use std::collections::HashSet;
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::ReferrerPolicy;
26use crate::blob_url_store::UrlWithBlobClaim;
27use crate::policy_container::{PolicyContainer, RequestPolicyContainer};
28use crate::pub_domains::{Site, is_same_site};
29use crate::resource_fetch_timing::ResourceTimingType;
30use crate::response::{RedirectTaint, Response};
31
32pub type NetworkPartitionKey = Option<Site>;
35
36#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
37pub struct RequestId(pub Uuid);
39
40impl Default for RequestId {
41 fn default() -> Self {
42 Self(Uuid::new_v4())
43 }
44}
45
46#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
48pub enum Initiator {
49 None,
50 Download,
51 ImageSet,
52 Manifest,
53 XSLT,
54 Prefetch,
55 Link,
56}
57
58pub use csp::Destination;
60
61#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
63pub enum Origin {
64 Client,
65 Origin(ImmutableOrigin),
66}
67
68impl Origin {
69 pub fn is_opaque(&self) -> bool {
70 matches!(self, Origin::Origin(ImmutableOrigin::Opaque(_)))
71 }
72}
73
74#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
76pub enum Referrer {
77 NoReferrer,
78 Client(ServoUrl),
84 ReferrerUrl(ServoUrl),
85}
86
87#[derive(Clone, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
89pub enum RequestMode {
90 Navigate,
91 SameOrigin,
92 NoCors,
93 CorsMode,
94 WebSocket {
95 protocols: Vec<String>,
96 original_url: ServoUrl,
97 },
98}
99
100#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
102pub enum CredentialsMode {
103 Omit,
104 CredentialsSameOrigin,
105 Include,
106}
107
108#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
110pub enum CacheMode {
111 Default,
112 NoStore,
113 Reload,
114 NoCache,
115 ForceCache,
116 OnlyIfCached,
117}
118
119#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
121pub enum ServiceWorkersMode {
122 All,
123 None,
124}
125
126#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
128pub enum RedirectMode {
129 Follow,
130 Error,
131 Manual,
132}
133
134#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
136pub enum ResponseTainting {
137 Basic,
138 CorsTainting,
139 Opaque,
140}
141
142#[derive(Clone, Copy, Debug, Default, Deserialize, MallocSizeOf, PartialEq, Serialize)]
144pub enum InternalRequest {
145 Yes,
146 #[default]
147 No,
148}
149
150#[derive(Clone, Debug, Eq, Hash, Deserialize, MallocSizeOf, Serialize, PartialEq)]
152pub struct PreloadKey {
153 pub url: ServoUrl,
155 pub destination: Destination,
157 pub mode: RequestMode,
159 pub credentials_mode: CredentialsMode,
161}
162
163impl PreloadKey {
164 pub fn new(request: &RequestBuilder) -> Self {
165 Self {
166 url: request.url.url(),
167 destination: request.destination,
168 mode: request.mode.clone(),
169 credentials_mode: request.credentials_mode,
170 }
171 }
172}
173
174#[derive(PartialEq, Eq, Clone, Debug, Serialize, Deserialize, Hash, MallocSizeOf)]
175pub struct PreloadId(pub Uuid);
176
177impl Default for PreloadId {
178 fn default() -> Self {
179 Self(Uuid::new_v4())
180 }
181}
182
183#[derive(Debug, MallocSizeOf)]
185pub struct PreloadEntry {
186 pub integrity_metadata: String,
188 pub response: Option<Response>,
190 pub on_response_available: Option<TokioSender<Response>>,
192}
193
194impl PreloadEntry {
195 pub fn new(integrity_metadata: String) -> Self {
196 Self {
197 integrity_metadata,
198 response: None,
199 on_response_available: None,
200 }
201 }
202
203 pub fn with_response(&mut self, response: Response) {
205 if let Some(sender) = self.on_response_available.take() {
208 let _ = sender.send(response);
209 } else {
210 self.response = Some(response);
211 }
212 }
213}
214
215pub type PreloadedResources = FxHashMap<PreloadKey, PreloadId>;
216
217#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
219pub struct RequestClient {
220 pub preloaded_resources: PreloadedResources,
222 #[conditional_malloc_size_of]
224 pub policy_container: Arc<PolicyContainer>,
225 pub origin: Origin,
227 pub is_nested_browsing_context: bool,
229 pub insecure_requests_policy: InsecureRequestsPolicy,
231 pub upgrade_insecure_navigations_set: HashSet<UpgradeInsecureNavigations>,
233 pub has_trustworthy_ancestor_origin: bool,
235 pub network_partition_key: NetworkPartitionKey,
237}
238
239#[derive(Clone, Copy, Default, MallocSizeOf, PartialEq)]
241pub enum SystemVisibilityState {
242 #[default]
243 Hidden,
244 Visible,
245}
246
247#[derive(Clone, Copy, Default, MallocSizeOf, PartialEq)]
249pub struct TraversableNavigable {
250 current_session_history_step: u8,
252 running_nested_apply_history_step: bool,
256 system_visibility_state: SystemVisibilityState,
258 is_created_by_web_content: bool,
260}
261
262#[derive(Clone, Copy, MallocSizeOf, PartialEq)]
264pub enum TraversableForUserPrompts {
265 NoTraversable,
266 Client,
267 TraversableNavigable(TraversableNavigable),
268}
269
270#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
272pub enum CorsSettings {
273 Anonymous,
274 UseCredentials,
275}
276
277impl CorsSettings {
278 pub fn from_enumerated_attribute(value: &str) -> CorsSettings {
280 if value.eq_ignore_ascii_case("use-credentials") {
281 CorsSettings::UseCredentials
282 } else {
283 CorsSettings::Anonymous
284 }
285 }
286}
287
288#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
290pub enum ParserMetadata {
291 Default,
292 ParserInserted,
293 NotParserInserted,
294}
295
296#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
298pub enum BodySource {
299 Null,
300 Object,
301}
302
303#[derive(Debug, Deserialize, Serialize)]
306pub enum BodyChunkResponse {
307 Chunk(GenericSharedMemory),
309 Done,
311 Error,
314}
315
316#[derive(Debug, Deserialize, Serialize)]
321pub enum BodyChunkRequest {
322 Connect(IpcSender<BodyChunkResponse>),
324 Extract(IpcReceiver<BodyChunkRequest>),
326 Chunk,
328}
329
330#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
336pub struct RequestBody {
337 #[conditional_malloc_size_of]
339 body_chunk_request_channel: Arc<Mutex<Option<IpcSender<BodyChunkRequest>>>>,
340 source: BodySource,
342 total_bytes: Option<usize>,
344}
345
346impl RequestBody {
347 pub fn new(
348 body_chunk_request_channel: IpcSender<BodyChunkRequest>,
349 source: BodySource,
350 total_bytes: Option<usize>,
351 ) -> Self {
352 RequestBody {
353 body_chunk_request_channel: Arc::new(Mutex::new(Some(body_chunk_request_channel))),
354 source,
355 total_bytes,
356 }
357 }
358
359 pub fn extract_source(&mut self) {
361 match self.source {
362 BodySource::Null => panic!("Null sources should never be re-directed."),
363 BodySource::Object => {
364 let (chan, port) = ipc::channel().unwrap();
365 let mut lock = self.body_chunk_request_channel.lock();
366 let Some(selfchan) = lock.as_mut() else {
367 error!(
368 "Could not re-extract the request body source because the body stream has already been closed."
369 );
370 return;
371 };
372 if let Err(error) = selfchan.send(BodyChunkRequest::Extract(port)) {
373 error!(
374 "Could not re-extract the request body source because the body stream has already been closed: {error}"
375 );
376 return;
377 }
378 *selfchan = chan;
379 },
380 }
381 }
382
383 pub fn clone_stream(&self) -> Arc<Mutex<Option<IpcSender<BodyChunkRequest>>>> {
385 self.body_chunk_request_channel.clone()
386 }
387
388 pub fn close_stream(&self) {
393 self.body_chunk_request_channel.lock().take();
394 }
395
396 pub fn source_is_null(&self) -> bool {
397 self.source == BodySource::Null
398 }
399
400 #[expect(clippy::len_without_is_empty)]
401 pub fn len(&self) -> Option<usize> {
402 self.total_bytes
403 }
404}
405
406trait RequestBodySize {
407 fn body_length(&self) -> usize;
408}
409
410impl RequestBodySize for Option<RequestBody> {
411 fn body_length(&self) -> usize {
412 self.as_ref()
413 .and_then(|body| body.len())
414 .unwrap_or_default()
415 }
416}
417
418#[derive(Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize)]
419pub enum InsecureRequestsPolicy {
420 DoNotUpgrade,
421 Upgrade,
422}
423
424#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Eq, Hash, Serialize)]
425pub struct UpgradeInsecureNavigations {
426 pub host: String,
427 pub port: u16,
428}
429
430pub trait RequestHeadersSize {
431 fn total_size(&self) -> usize;
432}
433
434impl RequestHeadersSize for HeaderMap {
435 fn total_size(&self) -> usize {
436 self.iter()
437 .map(|(name, value)| name.as_str().len() + value.len())
438 .sum()
439 }
440}
441
442#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize)]
443pub struct RequestBuilder {
444 pub id: RequestId,
445
446 pub preload_id: Option<PreloadId>,
447
448 #[serde(
450 deserialize_with = "::hyper_serde::deserialize",
451 serialize_with = "::hyper_serde::serialize"
452 )]
453 pub method: Method,
454
455 pub url: UrlWithBlobClaim,
457
458 #[serde(
460 deserialize_with = "::hyper_serde::deserialize",
461 serialize_with = "::hyper_serde::serialize"
462 )]
463 pub headers: HeaderMap,
464
465 pub unsafe_request: bool,
467
468 pub body: Option<RequestBody>,
470 pub reload_navigation: bool,
473 pub history_navigation: bool,
476
477 pub service_workers_mode: ServiceWorkersMode,
479 pub client: Option<RequestClient>,
480 pub destination: Destination,
482 pub synchronous: bool,
483 pub mode: RequestMode,
484
485 pub cache_mode: CacheMode,
487
488 pub use_cors_preflight: bool,
490
491 pub keep_alive: bool,
493
494 pub credentials_mode: CredentialsMode,
496 pub use_url_credentials: bool,
497
498 pub origin: Origin,
500
501 pub policy_container: RequestPolicyContainer,
503
504 pub user_activation: bool,
506
507 pub referrer: Referrer,
509
510 pub referrer_policy: ReferrerPolicy,
512 pub pipeline_id: Option<PipelineId>,
513 pub target_webview_id: Option<WebViewId>,
514
515 pub redirect_mode: RedirectMode,
517
518 pub integrity_metadata: String,
520
521 pub cryptographic_nonce_metadata: String,
523
524 pub url_list: Vec<UrlWithBlobClaim>,
526
527 pub parser_metadata: ParserMetadata,
529
530 pub initiator: Initiator,
532 pub response_tainting: ResponseTainting,
533 pub crash: Option<String>,
535 pub is_internal_request: InternalRequest,
537}
538
539impl RequestBuilder {
540 pub fn new(
541 webview_id: Option<WebViewId>,
542 url: UrlWithBlobClaim,
543 referrer: Referrer,
544 ) -> RequestBuilder {
545 RequestBuilder {
546 id: RequestId::default(),
547 preload_id: None,
548 method: Method::GET,
549 url,
550 headers: HeaderMap::new(),
551 unsafe_request: false,
552 body: None,
553 reload_navigation: false,
554 history_navigation: false,
555 service_workers_mode: ServiceWorkersMode::All,
556 destination: Destination::None,
557 synchronous: false,
558 mode: RequestMode::NoCors,
559 cache_mode: CacheMode::Default,
560 use_cors_preflight: false,
561 keep_alive: false,
562 credentials_mode: CredentialsMode::CredentialsSameOrigin,
563 use_url_credentials: false,
564 user_activation: false,
565 origin: Origin::Client,
566 client: None,
567 policy_container: RequestPolicyContainer::default(),
568 referrer,
569 referrer_policy: ReferrerPolicy::EmptyString,
570 pipeline_id: None,
571 target_webview_id: webview_id,
572 redirect_mode: RedirectMode::Follow,
573 integrity_metadata: String::new(),
574 cryptographic_nonce_metadata: String::new(),
575 url_list: vec![],
576 parser_metadata: ParserMetadata::Default,
577 initiator: Initiator::None,
578 response_tainting: ResponseTainting::Basic,
579 is_internal_request: Default::default(),
580 crash: None,
581 }
582 }
583
584 pub fn preload_id(mut self, preload_id: PreloadId) -> RequestBuilder {
585 self.preload_id = Some(preload_id);
586 self
587 }
588
589 pub fn initiator(mut self, initiator: Initiator) -> RequestBuilder {
591 self.initiator = initiator;
592 self
593 }
594
595 pub fn method(mut self, method: Method) -> RequestBuilder {
597 self.method = method;
598 self
599 }
600
601 pub fn headers(mut self, headers: HeaderMap) -> RequestBuilder {
603 self.headers = headers;
604 self
605 }
606
607 pub fn unsafe_request(mut self, unsafe_request: bool) -> RequestBuilder {
609 self.unsafe_request = unsafe_request;
610 self
611 }
612
613 pub fn body(mut self, body: Option<RequestBody>) -> RequestBuilder {
615 self.body = body;
616 self
617 }
618
619 pub fn destination(mut self, destination: Destination) -> RequestBuilder {
621 self.destination = destination;
622 self
623 }
624
625 pub fn synchronous(mut self, synchronous: bool) -> RequestBuilder {
626 self.synchronous = synchronous;
627 self
628 }
629
630 pub fn mode(mut self, mode: RequestMode) -> RequestBuilder {
631 self.mode = mode;
632 self
633 }
634
635 pub fn use_cors_preflight(mut self, use_cors_preflight: bool) -> RequestBuilder {
637 self.use_cors_preflight = use_cors_preflight;
638 self
639 }
640
641 pub fn keep_alive(mut self, keep_alive: bool) -> RequestBuilder {
643 self.keep_alive = keep_alive;
644 self
645 }
646
647 pub fn user_activation(mut self, user_activation: bool) -> RequestBuilder {
649 self.user_activation = user_activation;
650 self
651 }
652
653 pub fn credentials_mode(mut self, credentials_mode: CredentialsMode) -> RequestBuilder {
655 self.credentials_mode = credentials_mode;
656 self
657 }
658
659 pub fn use_url_credentials(mut self, use_url_credentials: bool) -> RequestBuilder {
660 self.use_url_credentials = use_url_credentials;
661 self
662 }
663
664 pub fn origin(mut self, origin: ImmutableOrigin) -> RequestBuilder {
666 self.origin = Origin::Origin(origin);
667 self
668 }
669
670 pub fn referrer_policy(mut self, referrer_policy: ReferrerPolicy) -> RequestBuilder {
672 self.referrer_policy = referrer_policy;
673 self
674 }
675
676 pub fn url_list(mut self, url_list: Vec<UrlWithBlobClaim>) -> RequestBuilder {
678 self.url_list = url_list;
679 self
680 }
681
682 pub fn pipeline_id(mut self, pipeline_id: Option<PipelineId>) -> RequestBuilder {
683 self.pipeline_id = pipeline_id;
684 self
685 }
686
687 pub fn redirect_mode(mut self, redirect_mode: RedirectMode) -> RequestBuilder {
689 self.redirect_mode = redirect_mode;
690 self
691 }
692
693 pub fn integrity_metadata(mut self, integrity_metadata: String) -> RequestBuilder {
695 self.integrity_metadata = integrity_metadata;
696 self
697 }
698
699 pub fn cryptographic_nonce_metadata(mut self, nonce_metadata: String) -> RequestBuilder {
701 self.cryptographic_nonce_metadata = nonce_metadata;
702 self
703 }
704
705 pub fn parser_metadata(mut self, parser_metadata: ParserMetadata) -> RequestBuilder {
707 self.parser_metadata = parser_metadata;
708 self
709 }
710
711 pub fn response_tainting(mut self, response_tainting: ResponseTainting) -> RequestBuilder {
712 self.response_tainting = response_tainting;
713 self
714 }
715
716 pub fn crash(mut self, crash: Option<String>) -> Self {
717 self.crash = crash;
718 self
719 }
720
721 pub fn policy_container(mut self, policy_container: Arc<PolicyContainer>) -> RequestBuilder {
723 self.policy_container = RequestPolicyContainer::PolicyContainer(policy_container);
724 self
725 }
726
727 pub fn client(mut self, client: RequestClient) -> RequestBuilder {
729 self.client = Some(client);
730 self
731 }
732
733 pub fn service_workers_mode(
735 mut self,
736 service_workers_mode: ServiceWorkersMode,
737 ) -> RequestBuilder {
738 self.service_workers_mode = service_workers_mode;
739 self
740 }
741
742 pub fn cache_mode(mut self, cache_mode: CacheMode) -> RequestBuilder {
744 self.cache_mode = cache_mode;
745 self
746 }
747
748 pub fn is_internal_request(mut self, is_internal_request: InternalRequest) -> RequestBuilder {
749 self.is_internal_request = is_internal_request;
750 self
751 }
752
753 pub fn build(self) -> Request {
754 let mut request = Request::new(
755 self.id,
756 self.url.clone(),
757 Some(self.origin),
758 self.referrer,
759 self.pipeline_id,
760 self.target_webview_id,
761 );
762 request.preload_id = self.preload_id;
763 request.initiator = self.initiator;
764 request.method = self.method;
765 request.headers = self.headers;
766 request.unsafe_request = self.unsafe_request;
767 request.body = self.body;
768 request.reload_navigation = self.reload_navigation;
769 request.history_navigation = self.history_navigation;
770 request.service_workers_mode = self.service_workers_mode;
771 request.destination = self.destination;
772 request.synchronous = self.synchronous;
773 request.mode = self.mode;
774 request.use_cors_preflight = self.use_cors_preflight;
775 request.keep_alive = self.keep_alive;
776 request.credentials_mode = self.credentials_mode;
777 request.use_url_credentials = self.use_url_credentials;
778 request.cache_mode = self.cache_mode;
779 request.referrer_policy = self.referrer_policy;
780 request.redirect_mode = self.redirect_mode;
781 let mut url_list = self.url_list;
782 if url_list.is_empty() {
783 url_list.push(self.url);
784 }
785 request.redirect_count = url_list.len() as u32 - 1;
786 request.url_list = url_list;
787 request.integrity_metadata = self.integrity_metadata;
788 request.cryptographic_nonce_metadata = self.cryptographic_nonce_metadata;
789 request.parser_metadata = self.parser_metadata;
790 request.response_tainting = self.response_tainting;
791 request.crash = self.crash;
792 request.client = self.client;
793 request.user_activation = self.user_activation;
794 request.policy_container = self.policy_container;
795 request.is_internal_request = self.is_internal_request;
796 request
797 }
798
799 pub fn keep_alive_body_length(&self) -> u64 {
801 assert!(self.keep_alive);
802 self.body.body_length() as u64
803 }
804}
805
806#[derive(Clone, MallocSizeOf)]
809pub struct Request {
810 pub id: RequestId,
814 pub preload_id: Option<PreloadId>,
815 pub method: Method,
817 pub local_urls_only: bool,
819 pub headers: HeaderMap,
821 pub unsafe_request: bool,
823 pub body: Option<RequestBody>,
825 pub reload_navigation: bool,
828 pub history_navigation: bool,
831 pub client: Option<RequestClient>,
833 pub traversable_for_user_prompts: TraversableForUserPrompts,
835 pub target_webview_id: Option<WebViewId>,
836 pub keep_alive: bool,
838 pub service_workers_mode: ServiceWorkersMode,
840 pub initiator: Initiator,
842 pub destination: Destination,
844 pub origin: Origin,
847 pub referrer: Referrer,
849 pub referrer_policy: ReferrerPolicy,
851 pub pipeline_id: Option<PipelineId>,
852 pub synchronous: bool,
854 pub mode: RequestMode,
856 pub use_cors_preflight: bool,
858 pub credentials_mode: CredentialsMode,
860 pub use_url_credentials: bool,
862 pub cache_mode: CacheMode,
864 pub redirect_mode: RedirectMode,
866 pub integrity_metadata: String,
868 pub cryptographic_nonce_metadata: String,
870 pub url_list: Vec<UrlWithBlobClaim>,
872 pub redirect_count: u32,
874 pub response_tainting: ResponseTainting,
876 pub parser_metadata: ParserMetadata,
878 pub policy_container: RequestPolicyContainer,
880 pub user_activation: bool,
882 pub crash: Option<String>,
884 pub is_internal_request: InternalRequest,
886}
887
888impl Request {
889 pub fn new(
890 id: RequestId,
891 url: UrlWithBlobClaim,
892 origin: Option<Origin>,
893 referrer: Referrer,
894 pipeline_id: Option<PipelineId>,
895 webview_id: Option<WebViewId>,
896 ) -> Request {
897 Request {
898 id,
899 preload_id: None,
900 method: Method::GET,
901 local_urls_only: false,
902 headers: HeaderMap::new(),
903 unsafe_request: false,
904 body: None,
905 reload_navigation: false,
906 history_navigation: false,
907 client: None,
908 traversable_for_user_prompts: TraversableForUserPrompts::Client,
909 keep_alive: false,
910 service_workers_mode: ServiceWorkersMode::All,
911 initiator: Initiator::None,
912 destination: Destination::None,
913 origin: origin.unwrap_or(Origin::Client),
914 referrer,
915 referrer_policy: ReferrerPolicy::EmptyString,
916 pipeline_id,
917 target_webview_id: webview_id,
918 synchronous: false,
919 mode: RequestMode::NoCors,
920 use_cors_preflight: false,
921 credentials_mode: CredentialsMode::CredentialsSameOrigin,
922 use_url_credentials: false,
923 user_activation: false,
924 cache_mode: CacheMode::Default,
925 redirect_mode: RedirectMode::Follow,
926 integrity_metadata: String::new(),
927 cryptographic_nonce_metadata: String::new(),
928 url_list: vec![url],
929 parser_metadata: ParserMetadata::Default,
930 redirect_count: 0,
931 response_tainting: ResponseTainting::Basic,
932 policy_container: RequestPolicyContainer::Client,
933 is_internal_request: Default::default(),
934 crash: None,
935 }
936 }
937
938 pub fn url(&self) -> ServoUrl {
940 self.url_list.first().unwrap().url()
941 }
942
943 pub fn url_with_blob_claim(&self) -> UrlWithBlobClaim {
944 self.url_list.first().unwrap().clone()
945 }
946
947 pub fn original_url(&self) -> ServoUrl {
948 match self.mode {
949 RequestMode::WebSocket {
950 protocols: _,
951 ref original_url,
952 } => original_url.clone(),
953 _ => self.url(),
954 }
955 }
956
957 pub fn current_url(&self) -> ServoUrl {
959 self.current_url_with_blob_claim().url()
960 }
961
962 pub fn current_url_with_blob_claim(&self) -> UrlWithBlobClaim {
964 self.url_list.last().unwrap().clone()
965 }
966
967 pub fn current_url_mut(&mut self) -> &mut ServoUrl {
969 self.url_list.last_mut().unwrap()
970 }
971
972 pub fn is_navigation_request(&self) -> bool {
974 matches!(
975 self.destination,
976 Destination::Document |
977 Destination::Embed |
978 Destination::Frame |
979 Destination::IFrame |
980 Destination::Object
981 )
982 }
983
984 pub fn is_subresource_request(&self) -> bool {
986 matches!(
987 self.destination,
988 Destination::Audio |
989 Destination::AudioWorklet |
990 Destination::Font |
991 Destination::Image |
992 Destination::Json |
993 Destination::Manifest |
994 Destination::PaintWorklet |
995 Destination::Script |
996 Destination::Style |
997 Destination::Text |
998 Destination::Track |
999 Destination::Video |
1000 Destination::Xslt |
1001 Destination::None
1002 )
1003 }
1004
1005 pub fn timing_type(&self) -> ResourceTimingType {
1006 if self.is_navigation_request() {
1007 ResourceTimingType::Navigation
1008 } else {
1009 ResourceTimingType::Resource
1010 }
1011 }
1012
1013 pub fn populate_request_from_client(&mut self) {
1015 if self.traversable_for_user_prompts == TraversableForUserPrompts::Client {
1017 self.traversable_for_user_prompts = TraversableForUserPrompts::NoTraversable;
1019 if self.client.is_some() {
1021 self.traversable_for_user_prompts =
1026 TraversableForUserPrompts::TraversableNavigable(Default::default());
1027 }
1028 }
1029 if self.origin == Origin::Client {
1031 let Some(client) = self.client.as_ref() else {
1032 unreachable!();
1034 };
1035 self.origin = client.origin.clone();
1037 }
1038 if matches!(self.policy_container, RequestPolicyContainer::Client) {
1040 if let Some(client) = self.client.as_ref() {
1043 self.policy_container =
1044 RequestPolicyContainer::PolicyContainer(client.policy_container.clone());
1045 } else {
1046 self.policy_container =
1048 RequestPolicyContainer::PolicyContainer(Arc::new(PolicyContainer::default()));
1049 }
1050 }
1051 }
1052
1053 pub fn keep_alive_body_length(&self) -> u64 {
1055 assert!(self.keep_alive);
1056 self.body.body_length() as u64
1057 }
1058
1059 pub fn total_request_length(&self) -> usize {
1061 let mut total_request_length = self.url()[..Position::AfterQuery].len();
1063 total_request_length += self
1065 .referrer
1066 .to_url()
1067 .map(|url| url.as_str().len())
1068 .unwrap_or_default();
1069 total_request_length += self.headers.total_size();
1072 total_request_length += self.body.body_length();
1074 total_request_length
1076 }
1077
1078 pub fn redirect_taint_for_request(&self) -> RedirectTaint {
1080 let Origin::Origin(request_origin) = &self.origin else {
1082 unreachable!("origin cannot be \"client\" at this point in time");
1083 };
1084
1085 let mut last_url = None;
1087
1088 let mut taint = RedirectTaint::SameOrigin;
1090
1091 for url in &self.url_list {
1093 let Some(last_url) = &mut last_url else {
1095 last_url = Some(url);
1096 continue;
1097 };
1098
1099 if !is_same_site(&url.origin(), &last_url.origin()) &&
1102 !is_same_site(request_origin, &last_url.origin())
1103 {
1104 return RedirectTaint::CrossSite;
1105 }
1106
1107 if url.origin() != last_url.origin() && *request_origin != last_url.origin() {
1110 taint = RedirectTaint::SameSite;
1111 }
1112
1113 *last_url = url;
1115 }
1116
1117 taint
1119 }
1120}
1121
1122impl Referrer {
1123 pub fn to_url(&self) -> Option<&ServoUrl> {
1124 match *self {
1125 Referrer::NoReferrer => None,
1126 Referrer::Client(ref url) => Some(url),
1127 Referrer::ReferrerUrl(ref url) => Some(url),
1128 }
1129 }
1130}
1131
1132fn is_cors_unsafe_request_header_byte(value: &u8) -> bool {
1136 matches!(value,
1137 0x00..=0x08 |
1138 0x10..=0x19 |
1139 0x22 |
1140 0x28 |
1141 0x29 |
1142 0x3A |
1143 0x3C |
1144 0x3E |
1145 0x3F |
1146 0x40 |
1147 0x5B |
1148 0x5C |
1149 0x5D |
1150 0x7B |
1151 0x7D |
1152 0x7F
1153 )
1154}
1155
1156fn is_cors_safelisted_request_accept(value: &[u8]) -> bool {
1159 !(value.iter().any(is_cors_unsafe_request_header_byte))
1160}
1161
1162fn is_cors_safelisted_language(value: &[u8]) -> bool {
1165 value.iter().all(|&x| {
1166 matches!(x,
1167 0x30..=0x39 |
1168 0x41..=0x5A |
1169 0x61..=0x7A |
1170 0x20 |
1171 0x2A |
1172 0x2C |
1173 0x2D |
1174 0x2E |
1175 0x3B |
1176 0x3D
1177 )
1178 })
1179}
1180
1181pub fn is_cors_safelisted_request_content_type(value: &[u8]) -> bool {
1184 if value.iter().any(is_cors_unsafe_request_header_byte) {
1186 return false;
1187 }
1188 let value_string = if let Ok(s) = std::str::from_utf8(value) {
1190 s
1191 } else {
1192 return false;
1193 };
1194 let value_mime_result: Result<Mime, _> = value_string.parse();
1195 match value_mime_result {
1196 Err(_) => false, Ok(value_mime) => match (value_mime.type_(), value_mime.subtype()) {
1198 (mime::APPLICATION, mime::WWW_FORM_URLENCODED) |
1199 (mime::MULTIPART, mime::FORM_DATA) |
1200 (mime::TEXT, mime::PLAIN) => true,
1201 _ => false, },
1203 }
1204}
1205
1206pub fn is_cors_safelisted_request_header<N: AsRef<str>, V: AsRef<[u8]>>(
1210 name: &N,
1211 value: &V,
1212) -> bool {
1213 let name: &str = name.as_ref();
1214 let value: &[u8] = value.as_ref();
1215 if value.len() > 128 {
1216 return false;
1217 }
1218 match name {
1219 "accept" => is_cors_safelisted_request_accept(value),
1220 "accept-language" | "content-language" => is_cors_safelisted_language(value),
1221 "content-type" => is_cors_safelisted_request_content_type(value),
1222 "range" => is_cors_safelisted_request_range(value),
1223 _ => false,
1224 }
1225}
1226
1227pub fn is_cors_safelisted_request_range(value: &[u8]) -> bool {
1228 if let Ok(value_str) = std::str::from_utf8(value) {
1229 return validate_range_header(value_str);
1230 }
1231 false
1232}
1233
1234fn validate_range_header(value: &str) -> bool {
1235 let trimmed = value.trim();
1236 if !trimmed.starts_with("bytes=") {
1237 return false;
1238 }
1239
1240 if let Some(range) = trimmed.strip_prefix("bytes=") {
1241 let mut parts = range.split('-');
1242 let start = parts.next();
1243 let end = parts.next();
1244
1245 if let Some(start) = start &&
1246 let Ok(start_num) = start.parse::<u64>()
1247 {
1248 return match end {
1249 Some(e) if !e.is_empty() => {
1250 e.parse::<u64>().is_ok_and(|end_num| start_num <= end_num)
1251 },
1252 _ => true,
1253 };
1254 }
1255 }
1256 false
1257}
1258
1259pub fn is_cors_safelisted_method(method: &Method) -> bool {
1261 matches!(*method, Method::GET | Method::HEAD | Method::POST)
1262}
1263
1264pub fn is_cors_non_wildcard_request_header_name(name: &HeaderName) -> bool {
1266 name == AUTHORIZATION
1267}
1268
1269pub fn get_cors_unsafe_header_names(headers: &HeaderMap) -> Vec<HeaderName> {
1271 let mut unsafe_names: Vec<&HeaderName> = vec![];
1273 let mut potentillay_unsafe_names: Vec<&HeaderName> = vec![];
1275 let mut safelist_value_size = 0;
1277
1278 for (name, value) in headers.iter() {
1280 if !is_cors_safelisted_request_header(&name, &value) {
1281 unsafe_names.push(name);
1282 } else {
1283 potentillay_unsafe_names.push(name);
1284 safelist_value_size += value.as_ref().len();
1285 }
1286 }
1287
1288 if safelist_value_size > 1024 {
1290 unsafe_names.extend_from_slice(&potentillay_unsafe_names);
1291 }
1292
1293 convert_header_names_to_sorted_lowercase_set(unsafe_names)
1295}
1296
1297pub fn convert_header_names_to_sorted_lowercase_set(
1299 mut header_names: Vec<&HeaderName>,
1300) -> Vec<HeaderName> {
1301 header_names.sort_by(|a, b| a.as_str().partial_cmp(b.as_str()).unwrap());
1304 header_names.dedup();
1305 header_names.into_iter().cloned().collect()
1306}
1307
1308pub fn create_request_body_with_content(content: String) -> RequestBody {
1309 let content_bytes = GenericSharedMemory::from_vec(content.into_bytes());
1310 let content_len = content_bytes.len();
1311
1312 let (chunk_request_sender, chunk_request_receiver) = ipc::channel().unwrap();
1313 ROUTER.add_typed_route(
1314 chunk_request_receiver,
1315 Box::new(move |message| {
1316 let request = message.unwrap();
1317 if let BodyChunkRequest::Connect(sender) = request {
1318 let _ = sender.send(BodyChunkResponse::Chunk(content_bytes.clone()));
1319 let _ = sender.send(BodyChunkResponse::Done);
1320 }
1321 }),
1322 );
1323
1324 RequestBody::new(chunk_request_sender, BodySource::Object, Some(content_len))
1325}