1use std::borrow::ToOwned;
8use std::collections::HashMap;
9use std::fs::File;
10use std::io::{self, BufReader};
11use std::path::{Path, PathBuf};
12use std::sync::{Arc, Weak};
13use std::thread;
14
15use cookie::Cookie;
16use embedder_traits::GenericEmbedderProxy;
17use hyper_serde::Serde;
18use log::{debug, trace};
19use malloc_size_of_derive::MallocSizeOf;
20use net_traits::blob_url_store::{BlobTokenCommunicator, parse_blob_url};
21use net_traits::filemanager_thread::FileTokenCheck;
22use net_traits::pub_domains::public_suffix_list_size_of;
23use net_traits::request::{Destination, PreloadEntry, PreloadId, RequestBuilder, RequestId};
24use net_traits::response::{Response, ResponseInit};
25use net_traits::{
26 AsyncRuntime, CookieData, CookieSource, CoreResourceMsg, CoreResourceThread,
27 CustomResponseMediator, DiscardFetch, FetchChannels, FetchTaskTarget, NetworkError,
28 ResourceFetchTiming, ResourceThreads, ResourceTimingType, WebSocketDomAction,
29 WebSocketNetworkEvent,
30};
31use parking_lot::{Mutex, RwLock};
32use profile_traits::generic_callback::GenericCallback as ProfileGenericCallback;
33use profile_traits::mem::{
34 ProcessReports, ProfilerChan as MemProfilerChan, Report, ReportKind, ReportsChan,
35 perform_memory_report,
36};
37use profile_traits::path;
38use profile_traits::time::ProfilerChan;
39use rustc_hash::FxHashMap;
40use rustls_pki_types::CertificateDer;
41use rustls_pki_types::pem::PemObject;
42use serde::{Deserialize, Serialize};
43use servo_base::generic_channel::{
44 self, CallbackSetter, GenericReceiver, GenericReceiverSet, GenericSelectionResult,
45 GenericSender,
46};
47use servo_url::{ImmutableOrigin, ServoUrl};
48use tokio::sync::Mutex as TokioMutex;
49
50use crate::async_runtime::{init_async_runtime, spawn_task};
51use crate::connector::{
52 CACertificates, CertificateErrorOverrideManager, create_http_client, create_tls_config,
53};
54use crate::cookie::ServoCookie;
55use crate::cookie_storage::CookieStorage;
56use crate::embedder::NetToEmbedderMsg;
57use crate::fetch::cors_cache::CorsCache;
58use crate::fetch::fetch_params::{FetchParams, SharedPreloadedResources};
59use crate::fetch::methods::{
60 AutoRequestBodyStreamCloser, CancellationListener, FetchContext,
61 SharedInflightKeepAliveRecords, WebSocketChannel, fetch,
62 transfers_request_body_stream_to_later_manual_redirect,
63};
64use crate::filemanager_thread::FileManager;
65use crate::hsts::{self, HstsList};
66use crate::http_cache::{HttpCache, HttpCacheAssignment};
67use crate::http_loader::{HttpState, http_redirect_fetch};
68use crate::protocols::ProtocolRegistry;
69use crate::request_interceptor::RequestInterceptor;
70use crate::websocket_loader::create_handshake_request;
71
72fn load_root_cert_store_from_file(file_path: String) -> io::Result<Vec<CertificateDer<'static>>> {
74 let mut pem = BufReader::new(File::open(file_path)?);
75
76 let certs = CertificateDer::pem_reader_iter(&mut pem)
77 .filter_map(|cert| {
78 cert.inspect_err(|e| log::error!("Could not load certificate ({e}). Ignoring it."))
79 .ok()
80 })
81 .collect();
82 Ok(certs)
83}
84
85#[expect(clippy::too_many_arguments)]
87pub fn new_resource_threads(
88 devtools_sender: Option<crossbeam_channel::Sender<DevtoolsMessage>>,
89 time_profiler_chan: ProfilerChan,
90 mem_profiler_chan: MemProfilerChan,
91 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
92 config_dir: Option<PathBuf>,
93 certificate_path: Option<String>,
94 ignore_certificate_errors: bool,
95 protocols: Arc<ProtocolRegistry>,
96) -> (ResourceThreads, ResourceThreads, Box<dyn AsyncRuntime>) {
97 let async_runtime = init_async_runtime();
99
100 let ca_certificates = certificate_path
101 .and_then(|path| {
102 Some(CACertificates::Override(
103 load_root_cert_store_from_file(path).ok()?,
104 ))
105 })
106 .unwrap_or_default();
107
108 let (public_core, private_core) = new_core_resource_thread(
109 devtools_sender,
110 time_profiler_chan,
111 mem_profiler_chan,
112 embedder_proxy,
113 config_dir,
114 ca_certificates,
115 ignore_certificate_errors,
116 protocols,
117 );
118 (
119 ResourceThreads::new(public_core),
120 ResourceThreads::new(private_core),
121 async_runtime,
122 )
123}
124
125#[expect(clippy::too_many_arguments)]
127pub fn new_core_resource_thread(
128 devtools_sender: Option<crossbeam_channel::Sender<DevtoolsMessage>>,
129 time_profiler_chan: ProfilerChan,
130 mem_profiler_chan: MemProfilerChan,
131 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
132 config_dir: Option<PathBuf>,
133 ca_certificates: CACertificates<'static>,
134 ignore_certificate_errors: bool,
135 protocols: Arc<ProtocolRegistry>,
136) -> (CoreResourceThread, CoreResourceThread) {
137 let (public_setup_chan, public_setup_port) = generic_channel::channel().unwrap();
138 let (private_setup_chan, private_setup_port) = generic_channel::channel().unwrap();
139 let (report_chan, report_port) = generic_channel::channel().unwrap();
140 let (revoke_sender, revoke_receiver) = generic_channel::channel().unwrap();
141 let (refresh_sender, refresh_receiver) = generic_channel::channel().unwrap();
142
143 let blob_token_communicator = Arc::new(Mutex::new(BlobTokenCommunicator {
144 revoke_sender,
145 refresh_token_sender: refresh_sender,
146 }));
147 thread::Builder::new()
148 .name("ResourceManager".to_owned())
149 .spawn(move || {
150 let resource_manager = CoreResourceManager::new(
151 devtools_sender,
152 time_profiler_chan,
153 embedder_proxy.clone(),
154 ca_certificates.clone(),
155 ignore_certificate_errors,
156 blob_token_communicator,
157 );
158
159 let mut channel_manager = ResourceChannelManager {
160 resource_manager,
161 config_dir,
162 ca_certificates,
163 ignore_certificate_errors,
164 cancellation_listeners: Default::default(),
165 };
166
167 mem_profiler_chan.run_with_memory_reporting(
168 || {
169 channel_manager.start(
170 public_setup_port,
171 private_setup_port,
172 report_port,
173 revoke_receiver,
174 refresh_receiver,
175 protocols,
176 embedder_proxy,
177 )
178 },
179 String::from("network-cache-reporter"),
180 report_chan,
181 CoreResourceMsg::CollectMemoryReport,
182 );
183 })
184 .expect("Thread spawning failed");
185 (public_setup_chan, private_setup_chan)
186}
187
188struct ResourceChannelManager {
189 resource_manager: CoreResourceManager,
190 config_dir: Option<PathBuf>,
191 ca_certificates: CACertificates<'static>,
192 ignore_certificate_errors: bool,
193 cancellation_listeners: FxHashMap<RequestId, Weak<CancellationListener>>,
194}
195
196fn create_http_states(
198 config_dir: Option<&Path>,
199 ca_certificates: CACertificates<'static>,
200 ignore_certificate_errors: bool,
201 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
202) -> (Arc<HttpState>, Arc<HttpState>) {
203 let auth_cache = config_dir
204 .and_then(|config_dir| servo_base::read_json_from_file(config_dir, "auth_cache.json").ok())
205 .unwrap_or_default();
206 let hsts_list = config_dir
207 .and_then(|config_dir| servo_base::read_json_from_file(config_dir, "hsts_list.json").ok())
208 .unwrap_or_default();
209 let cookie_jar = config_dir
210 .and_then(|config_dir| servo_base::read_json_from_file(config_dir, "cookie_jar.json").ok())
211 .unwrap_or_else(|| CookieStorage::new(150));
212
213 let override_manager = CertificateErrorOverrideManager::new();
214 let http_state = HttpState {
215 hsts_list: RwLock::new(hsts_list),
216 cookie_jar: RwLock::new(cookie_jar),
217 auth_cache: RwLock::new(auth_cache),
218 cors_cache: RwLock::new(CorsCache::default()),
219 history_states: RwLock::new(FxHashMap::default()),
220 http_cache: HttpCache::new(HttpCacheAssignment::Public),
221 client: create_http_client(create_tls_config(
222 ca_certificates.clone(),
223 ignore_certificate_errors,
224 override_manager.clone(),
225 )),
226 override_manager,
227 embedder_proxy: embedder_proxy.clone(),
228 };
229
230 let override_manager = CertificateErrorOverrideManager::new();
231 let private_http_state = HttpState {
232 hsts_list: RwLock::new(HstsList::default()),
233 cookie_jar: RwLock::new(CookieStorage::new(150)),
234 auth_cache: RwLock::new(AuthCache::default()),
235 cors_cache: RwLock::new(CorsCache::default()),
236 history_states: RwLock::new(FxHashMap::default()),
237 http_cache: HttpCache::new(HttpCacheAssignment::Private),
238 client: create_http_client(create_tls_config(
239 ca_certificates,
240 ignore_certificate_errors,
241 override_manager.clone(),
242 )),
243 override_manager,
244 embedder_proxy,
245 };
246
247 (Arc::new(http_state), Arc::new(private_http_state))
248}
249
250impl ResourceChannelManager {
251 #[expect(clippy::too_many_arguments)]
252 fn start(
253 &mut self,
254 public_receiver: GenericReceiver<CoreResourceMsg>,
255 private_receiver: GenericReceiver<CoreResourceMsg>,
256 memory_reporter: GenericReceiver<CoreResourceMsg>,
257 revoke_receiver: GenericReceiver<CoreResourceMsg>,
258 refresh_receiver: GenericReceiver<CoreResourceMsg>,
259 protocols: Arc<ProtocolRegistry>,
260 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
261 ) {
262 let (public_http_state, private_http_state) = create_http_states(
263 self.config_dir.as_deref(),
264 self.ca_certificates.clone(),
265 self.ignore_certificate_errors,
266 embedder_proxy,
267 );
268
269 let mut rx_set = GenericReceiverSet::new();
270 let private_id = rx_set.add(private_receiver);
271 let public_id = rx_set.add(public_receiver);
272 let reporter_id = rx_set.add(memory_reporter);
273 let revoker_id = rx_set.add(revoke_receiver);
274 let refresh_id = rx_set.add(refresh_receiver);
275 let mut selector = rx_set.selector();
276
277 'outer: loop {
278 for received in selector.select().into_iter() {
279 match received {
280 GenericSelectionResult::ChannelClosed(_) => continue,
282 GenericSelectionResult::Error(error) => {
283 log::error!("Found selection error: {error}")
284 },
285 GenericSelectionResult::AllChannelsClosed(_) => break 'outer,
286 GenericSelectionResult::MessageReceived(id, msg) => {
287 if id == revoker_id {
288 let CoreResourceMsg::RevokeTokenForFile(revocation_request) = msg
289 else {
290 log::error!("Blob revocation channel received unexpected message");
291 continue;
292 };
293 self.resource_manager.filemanager.invalidate_token(
294 &FileTokenCheck::Required(revocation_request.token),
295 &revocation_request.blob_id,
296 )
297 } else if id == refresh_id {
298 let CoreResourceMsg::RefreshTokenForFile(refresh_request) = msg else {
299 log::error!("Blob revocation channel received unexpected message");
300 continue;
301 };
302
303 let FileTokenCheck::Required(refreshed_token) = self
304 .resource_manager
305 .filemanager
306 .get_token_for_file(&refresh_request.blob_id, true)
307 else {
308 unreachable!();
309 };
310 let _ = refresh_request.new_token_sender.send(refreshed_token);
311 } else if id == reporter_id {
312 if let CoreResourceMsg::CollectMemoryReport(report_chan) = msg {
313 self.process_report(
314 report_chan,
315 &public_http_state,
316 &private_http_state,
317 );
318 continue;
319 } else {
320 log::error!("memory reporter should only send CollectMemoryReport");
321 }
322 } else {
323 let group = if id == private_id {
324 &private_http_state
325 } else {
326 assert_eq!(id, public_id);
327 &public_http_state
328 };
329 if !self.process_msg(msg, group, Arc::clone(&protocols)) {
330 return;
331 }
332 }
333 },
334 }
335 }
336 }
337 log::info!("Resource thread terminated");
338 }
339
340 fn process_report(
341 &mut self,
342 msg: ReportsChan,
343 public_http_state: &Arc<HttpState>,
344 private_http_state: &Arc<HttpState>,
345 ) {
346 perform_memory_report(|ops| {
347 let mut reports = public_http_state.memory_reports("public", ops);
348 reports.extend(private_http_state.memory_reports("private", ops));
349 reports.extend(vec![
350 Report {
351 path: path!["hsts-preload-list"],
352 kind: ReportKind::ExplicitJemallocHeapSize,
353 size: hsts::hsts_preload_size_of(ops),
354 },
355 Report {
356 path: path!["public-suffix-list"],
357 kind: ReportKind::ExplicitJemallocHeapSize,
358 size: public_suffix_list_size_of(ops),
359 },
360 ]);
361 msg.send(ProcessReports::new(reports));
362 })
363 }
364
365 fn cancellation_listener(&self, request_id: RequestId) -> Option<Arc<CancellationListener>> {
366 self.cancellation_listeners
367 .get(&request_id)
368 .and_then(Weak::upgrade)
369 }
370
371 fn get_or_create_cancellation_listener(
372 &mut self,
373 request_id: RequestId,
374 ) -> Arc<CancellationListener> {
375 if let Some(listener) = self.cancellation_listener(request_id) {
376 return listener;
377 }
378
379 self.cancellation_listeners
381 .retain(|_, listener| listener.strong_count() > 0);
382
383 let cancellation_listener = Arc::new(Default::default());
384 self.cancellation_listeners
385 .insert(request_id, Arc::downgrade(&cancellation_listener));
386 cancellation_listener
387 }
388
389 fn process_msg(
391 &mut self,
392 msg: CoreResourceMsg,
393 http_state: &Arc<HttpState>,
394 protocols: Arc<ProtocolRegistry>,
395 ) -> bool {
396 match msg {
397 CoreResourceMsg::Fetch(request_builder, channels) => match channels {
398 FetchChannels::ResponseMsg(sender) => {
399 let cancellation_listener =
400 self.get_or_create_cancellation_listener(request_builder.id);
401 self.resource_manager.fetch(
402 request_builder,
403 None,
404 sender,
405 http_state,
406 cancellation_listener,
407 protocols,
408 );
409 },
410 FetchChannels::WebSocket {
411 event_sender,
412 action_receiver,
413 } => {
414 let cancellation_listener =
415 self.get_or_create_cancellation_listener(request_builder.id);
416
417 self.resource_manager.websocket_connect(
418 request_builder,
419 event_sender,
420 action_receiver,
421 http_state,
422 cancellation_listener,
423 protocols,
424 )
425 },
426 FetchChannels::Prefetch => self.resource_manager.fetch(
427 request_builder,
428 None,
429 DiscardFetch,
430 http_state,
431 Arc::new(Default::default()),
432 protocols,
433 ),
434 },
435 CoreResourceMsg::Cancel(request_ids) => {
436 for cancellation_listener in request_ids
437 .into_iter()
438 .filter_map(|request_id| self.cancellation_listener(request_id))
439 {
440 cancellation_listener.cancel();
441 }
442 },
443 CoreResourceMsg::DeleteCookiesForSites(sites, sender) => {
444 http_state
445 .cookie_jar
446 .write()
447 .delete_cookies_for_sites(&sites);
448 let _ = sender.send(());
449 },
450 CoreResourceMsg::DeleteSessionCookies(sender) => {
451 http_state.cookie_jar.write().clear_session_cookies();
452 let _ = sender.send(());
453 },
454 CoreResourceMsg::DeleteCookies(request, sender) => {
455 http_state
456 .cookie_jar
457 .write()
458 .clear_storage(request.as_ref());
459 if let Some(sender) = sender {
460 let _ = sender.send(());
461 }
462 return true;
463 },
464 CoreResourceMsg::DeleteCookie(request, name) => {
465 http_state
466 .cookie_jar
467 .write()
468 .delete_cookie_with_name(&request, name);
469 return true;
470 },
471 CoreResourceMsg::FetchRedirect(request_builder, res_init, sender) => {
472 let cancellation_listener =
473 self.get_or_create_cancellation_listener(request_builder.id);
474 self.resource_manager.fetch(
475 request_builder,
476 Some(res_init),
477 sender,
478 http_state,
479 cancellation_listener,
480 protocols,
481 )
482 },
483 CoreResourceMsg::SetCookieForUrl(request, cookie, source, sender) => {
484 self.resource_manager.set_cookie_for_url(
485 &request,
486 cookie.into_inner().to_owned(),
487 source,
488 http_state,
489 );
490 if let Some(sender) = sender {
491 let _ = sender.send(());
492 }
493 },
494 CoreResourceMsg::SetCookiesForUrl(request, cookies, source) => {
495 for cookie in cookies {
496 self.resource_manager.set_cookie_for_url(
497 &request,
498 cookie.into_inner(),
499 source,
500 http_state,
501 );
502 }
503 },
504 CoreResourceMsg::SetCookieForUrlAsync(cookie_store_id, url, cookie, source) => {
505 self.resource_manager.set_cookie_for_url(
506 &url,
507 cookie.into_inner().to_owned(),
508 source,
509 http_state,
510 );
511 http_state
512 .cookie_jar
513 .read()
514 .send_response(cookie_store_id, CookieData::Set(Ok(())));
515 },
516 CoreResourceMsg::GetCookieStringForUrl(url, consumer, source) => {
517 let mut cookie_jar = http_state.cookie_jar.write();
518 cookie_jar.remove_expired_cookies_for_url(&url);
519 consumer.send_or_ignore(cookie_jar.cookies_for_url(&url, source));
520 },
521 CoreResourceMsg::GetCookiesForUrl(url, consumer, source) => {
522 let mut cookie_jar = http_state.cookie_jar.write();
523 cookie_jar.remove_expired_cookies_for_url(&url);
524 let cookies = cookie_jar
525 .cookies_data_for_url(&url, source)
526 .map(Serde)
527 .collect();
528 consumer.send_or_ignore(cookies);
529 },
530 CoreResourceMsg::GetCookieDataForUrlAsync(cookie_store_id, url, name) => {
531 let mut cookie_jar = http_state.cookie_jar.write();
532 cookie_jar.remove_expired_cookies_for_url(&url);
533 let cookie = cookie_jar
534 .query_cookies(&url, name)
535 .into_iter()
536 .map(Serde)
537 .next();
538 cookie_jar.send_response(cookie_store_id, CookieData::Get(cookie));
539 },
540 CoreResourceMsg::GetAllCookieDataForUrlAsync(cookie_store_id, url, name) => {
541 let mut cookie_jar = http_state.cookie_jar.write();
542 cookie_jar.remove_expired_cookies_for_url(&url);
543 let cookies = cookie_jar
544 .query_cookies(&url, name)
545 .into_iter()
546 .map(Serde)
547 .collect();
548 cookie_jar.send_response(cookie_store_id, CookieData::GetAll(cookies));
549 },
550 CoreResourceMsg::EmbedderGetCookiesForUrl(operation_id, url, source) => {
551 let mut cookie_jar = http_state.cookie_jar.write();
552 cookie_jar.remove_expired_cookies_for_url(&url);
553 let cookies: Vec<Cookie<'static>> =
554 cookie_jar.cookies_data_for_url(&url, source).collect();
555 http_state.embedder_proxy.send(
556 NetToEmbedderMsg::EmbedderCookieOperationResponseWithCookies(
557 operation_id,
558 cookies,
559 ),
560 );
561 },
562 CoreResourceMsg::EmbedderSetCookieForUrl(operation_id, url, cookie, source) => {
563 self.resource_manager.set_cookie_for_url(
564 &url,
565 cookie.into_inner(),
566 source,
567 http_state,
568 );
569 http_state
570 .embedder_proxy
571 .send(NetToEmbedderMsg::EmbedderCookieOperationResponse(
572 operation_id,
573 ));
574 },
575 CoreResourceMsg::EmbedderClearCookies(operation_id) => {
576 http_state.cookie_jar.write().clear_storage(None);
577 http_state
578 .embedder_proxy
579 .send(NetToEmbedderMsg::EmbedderCookieOperationResponse(
580 operation_id,
581 ));
582 },
583 CoreResourceMsg::EmbedderClearSessionCookies(operation_id) => {
584 http_state.cookie_jar.write().clear_session_cookies();
585 http_state
586 .embedder_proxy
587 .send(NetToEmbedderMsg::EmbedderCookieOperationResponse(
588 operation_id,
589 ));
590 },
591 CoreResourceMsg::NewCookieListener(cookie_store_id, callback, url) => {
592 http_state
593 .cookie_jar
594 .write()
595 .add_listener(cookie_store_id, url, callback);
596 },
597 CoreResourceMsg::RemoveCookieListener(cookie_store_id) => {
598 http_state
599 .cookie_jar
600 .write()
601 .remove_listener(cookie_store_id);
602 },
603 CoreResourceMsg::NetworkMediator(mediator_chan, origin) => {
604 self.resource_manager
605 .sw_managers
606 .insert(origin, mediator_chan);
607 },
608 CoreResourceMsg::ListCookies(sender) => {
609 let mut cookie_jar = http_state.cookie_jar.write();
610 cookie_jar.remove_all_expired_cookies();
611 sender.send_or_ignore(cookie_jar.cookie_site_descriptors());
612 },
613 CoreResourceMsg::GetHistoryState(history_state_id, consumer) => {
614 let history_states = http_state.history_states.read();
615 consumer.send_or_ignore(history_states.get(&history_state_id).cloned());
616 },
617 CoreResourceMsg::SetHistoryState(history_state_id, structured_data) => {
618 let mut history_states = http_state.history_states.write();
619 history_states.insert(history_state_id, structured_data);
620 },
621 CoreResourceMsg::RemoveHistoryStates(states_to_remove) => {
622 let mut history_states = http_state.history_states.write();
623 for history_state in states_to_remove {
624 history_states.remove(&history_state);
625 }
626 },
627 CoreResourceMsg::GetCacheEntries(sender) => {
628 sender.send_or_ignore(http_state.http_cache.cache_entry_descriptors());
629 },
630 CoreResourceMsg::ClearCache(sender) => {
631 http_state.http_cache.clear();
632 if let Some(sender) = sender {
633 sender.send_or_ignore(());
634 }
635 },
636 CoreResourceMsg::ToFileManager(msg) => self.resource_manager.filemanager.handle(msg),
637 CoreResourceMsg::TotalSizeOfInFlightKeepAliveRecords(pipeline_id, sender) => {
638 let total = self
639 .resource_manager
640 .in_flight_keep_alive_records
641 .lock()
642 .get(&pipeline_id)
643 .map(|records| {
644 records
645 .iter()
646 .map(|record| record.keep_alive_body_length)
647 .sum()
648 })
649 .unwrap_or_default();
650 sender.send_or_ignore(total);
651 },
652 CoreResourceMsg::Exit(sender) => {
653 if let Some(ref config_dir) = self.config_dir {
654 let auth_cache = http_state.auth_cache.read();
655 servo_base::write_json_to_file(&*auth_cache, config_dir, "auth_cache.json");
656 let jar = http_state.cookie_jar.read();
657 servo_base::write_json_to_file(&*jar, config_dir, "cookie_jar.json");
658 let hsts = http_state.hsts_list.read();
659 servo_base::write_json_to_file(&*hsts, config_dir, "hsts_list.json");
660 }
661 self.resource_manager.exit();
662
663 let _ = sender.send(());
664 return false;
665 },
666 CoreResourceMsg::StoreCacheToDisk(sender) => {
667 let http_state = http_state.clone();
668 spawn_task(async move {
669 http_state.http_cache.drain_to_disk().await;
670 let _ = sender.send(());
671 })
672 },
673 CoreResourceMsg::CollectMemoryReport(_) |
675 CoreResourceMsg::RevokeTokenForFile(..) |
676 CoreResourceMsg::RefreshTokenForFile(..) => {},
677 }
678 true
679 }
680}
681
682#[derive(Clone, Debug, Deserialize, Serialize, MallocSizeOf)]
683pub struct AuthCacheEntry {
684 pub user_name: String,
685 pub password: String,
686}
687
688impl Default for AuthCache {
689 fn default() -> Self {
690 Self {
691 version: 1,
692 entries: HashMap::new(),
693 }
694 }
695}
696
697#[derive(Clone, Debug, Deserialize, Serialize, MallocSizeOf)]
698pub struct AuthCache {
699 pub version: u32,
700 pub entries: HashMap<String, AuthCacheEntry>,
701}
702
703#[cfg(feature = "devtools")]
704type DevtoolsMessage = devtools_traits::DevtoolsControlMsg;
705
706#[cfg(not(feature = "devtools"))]
707type DevtoolsMessage = ();
708
709pub struct CoreResourceManager {
710 devtools_sender: Option<crossbeam_channel::Sender<DevtoolsMessage>>,
711 sw_managers: HashMap<ImmutableOrigin, GenericSender<CustomResponseMediator>>,
712 filemanager: FileManager,
713 request_interceptor: RequestInterceptor,
714 ca_certificates: CACertificates<'static>,
715 ignore_certificate_errors: bool,
716 preloaded_resources: SharedPreloadedResources,
717 in_flight_keep_alive_records: SharedInflightKeepAliveRecords,
719}
720
721impl CoreResourceManager {
722 pub fn new(
723 devtools_sender: Option<crossbeam_channel::Sender<DevtoolsMessage>>,
724 _profiler_chan: ProfilerChan,
725 embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
726 ca_certificates: CACertificates<'static>,
727 ignore_certificate_errors: bool,
728 blob_token_communicator: Arc<Mutex<BlobTokenCommunicator>>,
729 ) -> CoreResourceManager {
730 CoreResourceManager {
731 devtools_sender,
732 sw_managers: Default::default(),
733 filemanager: FileManager::new(embedder_proxy.clone(), blob_token_communicator),
734 request_interceptor: RequestInterceptor::new(embedder_proxy),
735 ca_certificates,
736 ignore_certificate_errors,
737 preloaded_resources: Default::default(),
738 in_flight_keep_alive_records: Default::default(),
739 }
740 }
741
742 fn handle_preloaded_response(
743 preloaded_resources: SharedPreloadedResources,
744 preload_id: PreloadId,
745 response: Response,
746 ) {
747 let response = response
751 .get_network_error()
752 .map(|_| {
753 Response::network_error(NetworkError::ResourceLoadError("Failed to preload".into()))
754 })
755 .unwrap_or(response);
756 let mut preloaded_resources = preloaded_resources.lock().unwrap();
757 if let Some(entry) = preloaded_resources.get_mut(&preload_id) {
760 entry.with_response(response);
761 }
762 }
763
764 pub fn exit(&mut self) {
766 debug!("Exited CoreResourceManager");
767 }
768
769 fn set_cookie_for_url(
770 &mut self,
771 request: &ServoUrl,
772 cookie: Cookie<'static>,
773 source: CookieSource,
774 http_state: &Arc<HttpState>,
775 ) {
776 if let Some(cookie) = ServoCookie::new_wrapped(cookie, request, source) {
777 let mut cookie_jar = http_state.cookie_jar.write();
778 cookie_jar.push(cookie, request, source)
779 }
780 }
781
782 fn fetch<Target: 'static + FetchTaskTarget + Send>(
783 &self,
784 request_builder: RequestBuilder,
785 res_init_: Option<ResponseInit>,
786 mut sender: Target,
787 http_state: &Arc<HttpState>,
788 cancellation_listener: Arc<CancellationListener>,
789 protocols: Arc<ProtocolRegistry>,
790 ) {
791 let http_state = http_state.clone();
792 #[cfg(feature = "devtools")]
793 let devtools_chan = self.devtools_sender.clone();
794 let filemanager = self.filemanager.clone();
795 let request_interceptor = self.request_interceptor.clone();
796
797 let timing_type = match request_builder.destination {
798 Destination::Document => ResourceTimingType::Navigation,
799 _ => ResourceTimingType::Resource,
800 };
801
802 let request = request_builder.build();
803 let url = request.current_url();
804
805 let (file_token, blob_url_file_id) = match url.scheme() {
811 "blob" => {
812 if let Some(token) = request.current_url_with_blob_claim().token() {
813 (FileTokenCheck::Required(token.token), Some(token.file_id))
814 } else if let Ok(id) = parse_blob_url(&url) {
815 log::warn!(
817 "Failed to claim blob URL entry of valid blob URL before passing it to `net`. This causes race conditions."
818 );
819 (self.filemanager.get_token_for_file(&id, false), Some(id))
820 } else {
821 (FileTokenCheck::ShouldFail, None)
822 }
823 },
824 _ => (FileTokenCheck::NotRequired, None),
825 };
826
827 let ca_certificates = self.ca_certificates.clone();
828 let ignore_certificate_errors = self.ignore_certificate_errors;
829 let in_flight_keep_alive_records = self.in_flight_keep_alive_records.clone();
830 let preloaded_resources = self.preloaded_resources.clone();
831 if let Some(ref preload_id) = request.preload_id {
832 let mut preloaded_resources = self.preloaded_resources.lock().unwrap();
833 let entry = PreloadEntry::new(request.integrity_metadata.clone());
834 preloaded_resources.insert(preload_id.clone(), entry);
835 }
836
837 spawn_task(async move {
838 let context = FetchContext {
843 state: http_state,
844 user_agent: servo_config::pref!(user_agent),
845 #[cfg(feature = "devtools")]
846 devtools_chan,
847 filemanager,
848 file_token,
849 request_interceptor: Arc::new(TokioMutex::new(request_interceptor)),
850 cancellation_listener,
851 protocols,
852 websocket_chan: None,
853 ca_certificates,
854 ignore_certificate_errors,
855 preloaded_resources: preloaded_resources.clone(),
856 in_flight_keep_alive_records,
857 };
858
859 match res_init_ {
860 Some(res_init) => {
861 let response = Response::from_init(res_init, timing_type);
862
863 let timing = ResourceFetchTiming::new(request.timing_type()).into();
864 let mut fetch_params = FetchParams::new(request, timing);
865 let mut request_body_stream_closer =
866 AutoRequestBodyStreamCloser::new(fetch_params.request.body.as_ref());
867 let response = http_redirect_fetch(
868 &mut fetch_params,
869 response,
870 true,
871 &mut sender,
872 &mut None,
873 &context,
874 )
875 .await;
876 if transfers_request_body_stream_to_later_manual_redirect(
877 &fetch_params.request,
878 &response,
879 ) {
880 request_body_stream_closer.disarm();
881 }
882 },
883 None => {
884 let preload_id = request.preload_id.clone();
885 let response = fetch(request, &mut sender, &context).await;
886 if let Some(preload_id) = preload_id {
887 Self::handle_preloaded_response(preloaded_resources, preload_id, response);
888 }
889 },
890 };
891
892 if let Some(id) = blob_url_file_id.as_ref() {
894 context
895 .filemanager
896 .invalidate_token(&context.file_token, id);
897 }
898 });
899 }
900
901 fn websocket_connect(
903 &self,
904 mut request: RequestBuilder,
905 event_sender: ProfileGenericCallback<WebSocketNetworkEvent>,
906 action_receiver: CallbackSetter<WebSocketDomAction>,
907 http_state: &Arc<HttpState>,
908 cancellation_listener: Arc<CancellationListener>,
909 protocols: Arc<ProtocolRegistry>,
910 ) {
911 let http_state = http_state.clone();
912 #[cfg(feature = "devtools")]
913 let devtools_chan = self.devtools_sender.clone();
914 let filemanager = self.filemanager.clone();
915 let request_interceptor = self.request_interceptor.clone();
916
917 let ca_certificates = self.ca_certificates.clone();
918 let ignore_certificate_errors = self.ignore_certificate_errors;
919 let in_flight_keep_alive_records = self.in_flight_keep_alive_records.clone();
920 let preloaded_resources = self.preloaded_resources.clone();
921
922 spawn_task(async move {
923 let mut event_sender = event_sender;
924
925 let scheme = match request.url.scheme() {
928 "ws" => "http",
929 _ => "https",
930 };
931 request
932 .url
933 .as_mut_url()
934 .set_scheme(scheme)
935 .unwrap_or_else(|_| panic!("Can't set scheme to {scheme}"));
936
937 match create_handshake_request(request, http_state.clone()) {
938 Ok(request) => {
939 let context = FetchContext {
940 state: http_state,
941 user_agent: servo_config::pref!(user_agent),
942 #[cfg(feature = "devtools")]
943 devtools_chan,
944 filemanager,
945 file_token: FileTokenCheck::NotRequired,
946 request_interceptor: Arc::new(TokioMutex::new(request_interceptor)),
947 cancellation_listener,
948 protocols: protocols.clone(),
949 websocket_chan: Some(Arc::new(Mutex::new(WebSocketChannel::new(
950 event_sender.clone(),
951 Some(action_receiver),
952 )))),
953 ca_certificates,
954 ignore_certificate_errors,
955 preloaded_resources,
956 in_flight_keep_alive_records,
957 };
958 fetch(request, &mut event_sender, &context).await;
959 },
960 Err(e) => {
961 trace!("unable to create websocket handshake request {:?}", e);
962 let _ = event_sender.send(WebSocketNetworkEvent::Fail);
963 },
964 }
965 });
966 }
967}