Skip to main content

net/
resource_thread.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5//! A thread that takes a URL and streams back the binary data.
6
7use 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
72/// Load a file with CA certificate and produce a RootCertStore with the results.
73fn 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/// Returns a tuple of (public, private) senders to the new threads.
86#[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    // Initialize the async runtime, and get a handle to it for use in clean shutdown.
98    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/// Create a CoreResourceThread
126#[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
196/// This returns a tuple HttpState and a private HttpState.
197fn 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                    // Handles case where profiler thread shuts down before resource thread.
281                    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        // Clear away any cancellation listeners that are no longer valid.
380        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    /// Returns false if the thread should exit.
390    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            // Ignore these messages as they are only sent on very specific channels.
674            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    /// <https://fetch.spec.whatwg.org/#concept-fetch-record>
718    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        // https://html.spec.whatwg.org/multipage/#preload
748        // Step 11.1. If bodyBytes is a byte sequence, then set response's body to bodyBytes as a body.
749        // Step 11.2. Otherwise, set response to a network error.
750        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        // Step 11.5. If entry's on response available is null, then set entry's response to response;
758        // otherwise call entry's on response available given response.
759        if let Some(entry) = preloaded_resources.get_mut(&preload_id) {
760            entry.with_response(response);
761        }
762    }
763
764    /// Exit the core resource manager.
765    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        // In the case of a valid blob URL, acquiring a token granting access to a file,
806        // regardless if the URL is revoked after token acquisition.
807        //
808        // Ideally all callers should have claimed the blob entry themselves, but we're not there
809        // yet.
810        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                    // See https://github.com/servo/servo/issues/25226
816                    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            // XXXManishearth: Check origin against pipeline id (also ensure that the mode is allowed)
839            // todo load context / mimesniff in fetch
840            // todo referrer policy?
841            // todo service worker stuff
842            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            // Remove token after fetch.
893            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    /// <https://websockets.spec.whatwg.org/#concept-websocket-establish>
902    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 requestURL be a copy of url, with its scheme set to "http", if url’s scheme is
926            // "ws"; otherwise to "https"
927            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}