Skip to main content

net/
filemanager_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
5use std::fs::File;
6use std::io::{BufRead, BufReader, Seek, SeekFrom};
7use std::ops::Index;
8use std::path::{Path, PathBuf};
9use std::sync::Arc;
10use std::sync::atomic::{self, AtomicBool, AtomicUsize, Ordering};
11
12use bytes::Bytes;
13use embedder_traits::{
14    EmbedderControlId, EmbedderControlResponse, FilePickerRequest, GenericEmbedderProxy,
15    SelectedFile,
16};
17use headers::{ContentLength, ContentRange, ContentType, HeaderMap, HeaderMapExt, Range};
18use log::warn;
19use mime::Mime;
20use net_traits::blob_url_store::{BlobBuf, BlobTokenCommunicator, BlobURLStoreError};
21use net_traits::filemanager_thread::{
22    FileManagerResult, FileManagerThreadError, FileManagerThreadMsg, FileTokenCheck,
23    GetTokenForFileReply, ReadFileProgress, RelativePos,
24};
25use net_traits::response::{Response, ResponseBody};
26use parking_lot::{Mutex, RwLock};
27use profile_traits::generic_callback::GenericCallback;
28use rustc_hash::{FxHashMap, FxHashSet};
29use servo_arc::Arc as ServoArc;
30use servo_base::generic_channel::GenericSender;
31use servo_url::ImmutableOrigin;
32use tokio::io::{AsyncReadExt, AsyncSeekExt};
33use tokio::sync::mpsc::UnboundedSender as TokioSender;
34use tokio::task::yield_now;
35use uuid::Uuid;
36use walkdir::WalkDir;
37
38use crate::async_runtime::spawn_task;
39use crate::embedder::NetToEmbedderMsg;
40use crate::fetch::methods::{CancellationListener, Data, RangeRequestBounds};
41use crate::protocols::get_range_request_bounds;
42
43pub const FILE_CHUNK_SIZE: usize = 32768; // 32 KB
44
45/// FileManagerStore's entry
46struct FileStoreEntry {
47    /// Origin of the entry's "creator"
48    origin: ImmutableOrigin,
49    /// Backend implementation
50    file_impl: FileImpl,
51    /// Number of FileID holders that the ID is used to
52    /// index this entry in `FileManagerStore`.
53    /// Reference holders include a FileStoreEntry or
54    /// a script-side File-based Blob
55    refs: AtomicUsize,
56    /// UUIDs only become valid blob URIs when explicitly requested
57    /// by the user with createObjectURL. Validity can be revoked as well.
58    /// (The UUID is the one that maps to this entry in `FileManagerStore`)
59    is_valid_url: AtomicBool,
60    /// UUIDs of fetch instances that acquired an interest in this file,
61    /// when the url was still valid.
62    outstanding_tokens: FxHashSet<Uuid>,
63}
64
65#[derive(Clone)]
66struct FileMetaData {
67    path: PathBuf,
68    size: u64,
69}
70
71/// File backend implementation
72#[derive(Clone)]
73enum FileImpl {
74    /// Metadata of on-disk file
75    MetaDataOnly(FileMetaData),
76    /// In-memory Blob buffer object
77    Memory(BlobBuf),
78    /// A reference to parent entry in `FileManagerStore`,
79    /// representing a sliced version of the parent entry data
80    Sliced(Uuid, RelativePos),
81}
82
83#[derive(Clone)]
84pub struct FileManager {
85    embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
86    store: Arc<FileManagerStore>,
87    blob_token_communicator: Arc<Mutex<BlobTokenCommunicator>>,
88}
89
90impl FileManager {
91    pub fn new(
92        embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
93        blob_token_communicator: Arc<Mutex<BlobTokenCommunicator>>,
94    ) -> FileManager {
95        FileManager {
96            embedder_proxy,
97            store: Arc::new(FileManagerStore::new()),
98            blob_token_communicator,
99        }
100    }
101
102    fn read_file(
103        &self,
104        sender: GenericCallback<FileManagerResult<ReadFileProgress>>,
105        id: Uuid,
106        origin: ImmutableOrigin,
107    ) {
108        let store = self.store.clone();
109        spawn_task(async move {
110            if let Err(e) = store.try_read_file(&sender, id, origin).await {
111                let _ = sender.send(Err(FileManagerThreadError::BlobURLStoreError(e)));
112            }
113        });
114    }
115
116    pub(crate) fn get_token_for_file(&self, file_id: &Uuid, allow_revoked: bool) -> FileTokenCheck {
117        self.store.get_token_for_file(file_id, allow_revoked)
118    }
119
120    pub(crate) fn invalidate_token(&self, token: &FileTokenCheck, file_id: &Uuid) {
121        self.store.invalidate_token(token, file_id);
122    }
123
124    /// Read a file for the Fetch implementation.
125    /// It gets the required headers synchronously and reads the actual content
126    /// in a separate thread.
127    #[expect(clippy::too_many_arguments)]
128    pub(crate) fn fetch_file(
129        &self,
130        done_sender: &mut TokioSender<Data>,
131        cancellation_listener: Arc<CancellationListener>,
132        id: Uuid,
133        file_token: &FileTokenCheck,
134        origin: ImmutableOrigin,
135        response: &mut Response,
136        range: Option<Range>,
137    ) -> Result<(), BlobURLStoreError> {
138        self.fetch_blob_buf(
139            done_sender,
140            cancellation_listener,
141            &id,
142            file_token,
143            &origin,
144            BlobBounds::Unresolved(range),
145            response,
146        )
147    }
148
149    pub fn promote_memory(
150        &self,
151        id: Uuid,
152        blob_buf: BlobBuf,
153        set_valid: bool,
154        origin: ImmutableOrigin,
155    ) {
156        self.store.promote_memory(id, blob_buf, set_valid, origin);
157    }
158
159    /// Message handler
160    pub fn handle(&self, msg: FileManagerThreadMsg) {
161        match msg {
162            FileManagerThreadMsg::SelectFiles(control_id, file_picker_request, response_sender) => {
163                let store = self.store.clone();
164                let embedder = self.embedder_proxy.clone();
165                spawn_task(async move {
166                    let embedder_control_msg = store
167                        .select_files(control_id, file_picker_request, embedder)
168                        .await;
169                    response_sender.send(embedder_control_msg).unwrap();
170                });
171            },
172            FileManagerThreadMsg::ReadFile(sender, id, origin) => {
173                self.read_file(sender, id, origin);
174            },
175            FileManagerThreadMsg::PromoteMemory(id, blob_buf, set_valid, origin) => {
176                self.promote_memory(id, blob_buf, set_valid, origin);
177            },
178            FileManagerThreadMsg::AddSlicedURLEntry(id, rel_pos, sender, origin) => {
179                self.store.add_sliced_url_entry(id, rel_pos, sender, origin);
180            },
181            FileManagerThreadMsg::DecRef(id, origin, sender) => {
182                let _ = sender.send(self.store.dec_ref(&id, &origin));
183            },
184            FileManagerThreadMsg::RevokeBlobURL(id, origin, sender) => {
185                let _ = sender.send(self.store.set_blob_url_validity(false, &id, &origin));
186            },
187            FileManagerThreadMsg::ActivateBlobURL(id, sender, origin) => {
188                let _ = sender.send(self.store.set_blob_url_validity(true, &id, &origin));
189            },
190            FileManagerThreadMsg::GetTokenForFile(id, sender) => {
191                let token = match self.get_token_for_file(&id, false) {
192                    FileTokenCheck::Required(token) => Some(token),
193                    _ => None,
194                };
195
196                let communicator = self.blob_token_communicator.lock();
197                let _ = sender.send(GetTokenForFileReply {
198                    token,
199                    revoke_sender: communicator.revoke_sender.clone(),
200                    refresh_sender: communicator.refresh_token_sender.clone(),
201                });
202            },
203            FileManagerThreadMsg::RevokeTokenForFile(token, id) => {
204                self.invalidate_token(&FileTokenCheck::Required(token), &id);
205            },
206        }
207    }
208
209    pub fn fetch_file_in_chunks(
210        &self,
211        done_sender: &mut TokioSender<Data>,
212        mut reader: impl BufRead + Send + 'static,
213        res_body: ServoArc<Mutex<ResponseBody>>,
214        cancellation_listener: Arc<CancellationListener>,
215        range: RelativePos,
216    ) {
217        let done_sender = done_sender.clone();
218        spawn_task(async move {
219            loop {
220                if cancellation_listener.cancelled() {
221                    *res_body.lock() = ResponseBody::Done(vec![]);
222                    let _ = done_sender.send(Data::Cancelled);
223                    return;
224                }
225                let length = {
226                    let buffer = reader.fill_buf().unwrap();
227                    let mut buffer_len = buffer.len();
228                    if let ResponseBody::Receiving(ref mut body) = *res_body.lock() {
229                        let offset = usize::min(
230                            {
231                                if let Some(end) = range.end {
232                                    // HTTP Range requests are specified with closed ranges,
233                                    // while Rust uses half-open ranges. We add +1 here so
234                                    // we don't skip the last requested byte.
235                                    let remaining_bytes =
236                                        end as usize - range.start as usize - body.len() + 1;
237                                    if remaining_bytes <= FILE_CHUNK_SIZE {
238                                        // This is the last chunk so we set buffer
239                                        // len to 0 to break the reading loop.
240                                        buffer_len = 0;
241                                        remaining_bytes
242                                    } else {
243                                        FILE_CHUNK_SIZE
244                                    }
245                                } else {
246                                    FILE_CHUNK_SIZE
247                                }
248                            },
249                            buffer.len(),
250                        );
251                        let chunk = &buffer[0..offset];
252                        body.extend_from_slice(chunk);
253                        let _ = done_sender.send(Data::Payload(Bytes::copy_from_slice(chunk)));
254                    }
255                    buffer_len
256                };
257                if length == 0 {
258                    let mut body = res_body.lock();
259                    let completed_body = match *body {
260                        ResponseBody::Receiving(ref mut body) => std::mem::take(body),
261                        _ => vec![],
262                    };
263                    *body = ResponseBody::Done(completed_body);
264                    let _ = done_sender.send(Data::Done);
265                    break;
266                }
267                reader.consume(length);
268                yield_now().await
269            }
270        });
271    }
272
273    #[expect(clippy::too_many_arguments)]
274    fn fetch_blob_buf(
275        &self,
276        done_sender: &mut TokioSender<Data>,
277        cancellation_listener: Arc<CancellationListener>,
278        id: &Uuid,
279        file_token: &FileTokenCheck,
280        origin_in: &ImmutableOrigin,
281        bounds: BlobBounds,
282        response: &mut Response,
283    ) -> Result<(), BlobURLStoreError> {
284        let file_impl = self.store.get_impl(id, file_token, origin_in)?;
285        /*
286           Only Fetch Blob Range Request would have unresolved range, and only in that case we care about range header.
287        */
288        let mut is_range_requested = false;
289        match file_impl {
290            FileImpl::Memory(buf) => {
291                let bounds = match bounds {
292                    BlobBounds::Unresolved(range) => {
293                        if range.is_some() {
294                            is_range_requested = true;
295                        }
296                        get_range_request_bounds(range, buf.size)
297                    },
298                    BlobBounds::Resolved(bounds) => bounds,
299                };
300                let range = bounds
301                    .get_final(Some(buf.size))
302                    .map_err(|_| BlobURLStoreError::InvalidRange)?;
303
304                let range = range.to_abs_blob_range(buf.size as usize);
305                let len = range.len() as u64;
306                let content_range = if is_range_requested {
307                    ContentRange::bytes(range.start as u64..range.end as u64, buf.size).ok()
308                } else {
309                    None
310                };
311
312                set_blob_response_headers(
313                    &mut response.headers,
314                    len,
315                    buf.type_string.parse().unwrap_or(mime::TEXT_PLAIN),
316                    content_range,
317                );
318
319                let mut bytes = vec![];
320                bytes.extend_from_slice(buf.bytes.index(range));
321
322                let _ = done_sender.send(Data::Payload(Bytes::copy_from_slice(&bytes)));
323                let _ = done_sender.send(Data::Done);
324
325                Ok(())
326            },
327            FileImpl::MetaDataOnly(metadata) => {
328                /* XXX: Snapshot state check (optional) https://w3c.github.io/FileAPI/#snapshot-state.
329                        Concretely, here we create another file, and this file might not
330                        has the same underlying file state (meta-info plus content) as the time
331                        create_entry is called.
332                */
333
334                let file = File::open(&metadata.path)
335                    .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
336                let mut is_range_requested = false;
337                let bounds = match bounds {
338                    BlobBounds::Unresolved(range) => {
339                        if range.is_some() {
340                            is_range_requested = true;
341                        }
342                        get_range_request_bounds(range, metadata.size)
343                    },
344                    BlobBounds::Resolved(bounds) => bounds,
345                };
346                let range = bounds
347                    .get_final(Some(metadata.size))
348                    .map_err(|_| BlobURLStoreError::InvalidRange)?;
349
350                let mut reader = BufReader::with_capacity(FILE_CHUNK_SIZE, file);
351                if reader.seek(SeekFrom::Start(range.start as u64)).is_err() {
352                    return Err(BlobURLStoreError::External(
353                        "Unexpected method for blob".into(),
354                    ));
355                }
356
357                let content_range = if is_range_requested {
358                    let abs_range = range.to_abs_blob_range(metadata.size as usize);
359                    ContentRange::bytes(abs_range.start as u64..abs_range.end as u64, metadata.size)
360                        .ok()
361                } else {
362                    None
363                };
364                set_blob_response_headers(
365                    &mut response.headers,
366                    metadata.size,
367                    mime_guess::from_path(metadata.path)
368                        .first()
369                        .unwrap_or(mime::TEXT_PLAIN),
370                    content_range,
371                );
372
373                self.fetch_file_in_chunks(
374                    &mut done_sender.clone(),
375                    reader,
376                    response.body.clone(),
377                    cancellation_listener,
378                    range,
379                );
380
381                Ok(())
382            },
383            FileImpl::Sliced(parent_id, inner_rel_pos) => {
384                // Next time we don't need to check validity since
385                // we have already done that for requesting URL if necessary.
386                let bounds = RangeRequestBounds::Final(
387                    RelativePos::full_range().slice_inner(&inner_rel_pos),
388                );
389                self.fetch_blob_buf(
390                    done_sender,
391                    cancellation_listener,
392                    &parent_id,
393                    file_token,
394                    origin_in,
395                    BlobBounds::Resolved(bounds),
396                    response,
397                )
398            },
399        }
400    }
401}
402
403enum BlobBounds {
404    Unresolved(Option<Range>),
405    Resolved(RangeRequestBounds),
406}
407
408/// File manager's data store. It maintains a thread-safe mapping
409/// from FileID to FileStoreEntry which might have different backend implementation.
410/// Access to the content is encapsulated as methods of this struct.
411struct FileManagerStore {
412    entries: RwLock<FxHashMap<Uuid, FileStoreEntry>>,
413}
414
415impl FileManagerStore {
416    fn new() -> Self {
417        FileManagerStore {
418            entries: RwLock::new(FxHashMap::default()),
419        }
420    }
421
422    /// Copy out the file backend implementation content
423    fn get_impl(
424        &self,
425        id: &Uuid,
426        file_token: &FileTokenCheck,
427        origin_in: &ImmutableOrigin,
428    ) -> Result<FileImpl, BlobURLStoreError> {
429        match self.entries.read().get(id) {
430            Some(entry) => {
431                if *origin_in != entry.origin {
432                    Err(BlobURLStoreError::InvalidOrigin)
433                } else {
434                    match file_token {
435                        FileTokenCheck::NotRequired => Ok(entry.file_impl.clone()),
436                        FileTokenCheck::Required(token) => {
437                            if entry.outstanding_tokens.contains(token) {
438                                return Ok(entry.file_impl.clone());
439                            }
440                            Err(BlobURLStoreError::InvalidFileID)
441                        },
442                        FileTokenCheck::ShouldFail => Err(BlobURLStoreError::InvalidFileID),
443                    }
444                }
445            },
446            None => Err(BlobURLStoreError::InvalidFileID),
447        }
448    }
449
450    fn invalidate_token(&self, token: &FileTokenCheck, file_id: &Uuid) {
451        if let FileTokenCheck::Required(token) = token {
452            let mut entries = self.entries.write();
453            if let Some(entry) = entries.get_mut(file_id) {
454                entry.outstanding_tokens.remove(token);
455
456                // Check if there are references left.
457                let zero_refs = entry.refs.load(Ordering::Acquire) == 0;
458
459                // Check if no other fetch has acquired a token for this file.
460                let no_outstanding_tokens = entry.outstanding_tokens.is_empty();
461
462                // Check if there is still a blob URL outstanding.
463                let valid = entry.is_valid_url.load(Ordering::Acquire);
464
465                // Can we remove this file?
466                let do_remove = zero_refs && no_outstanding_tokens && !valid;
467
468                if do_remove {
469                    entries.remove(file_id);
470                }
471            }
472        }
473    }
474
475    pub(crate) fn get_token_for_file(&self, file_id: &Uuid, allow_revoked: bool) -> FileTokenCheck {
476        let mut entries = self.entries.write();
477        let parent_id = match entries.get(file_id) {
478            Some(entry) => {
479                if let FileImpl::Sliced(ref parent_id, _) = entry.file_impl {
480                    Some(*parent_id)
481                } else {
482                    None
483                }
484            },
485            None => return FileTokenCheck::ShouldFail,
486        };
487        let file_id = parent_id.as_ref().unwrap_or(file_id);
488
489        if let Some(entry) = entries.get_mut(file_id) {
490            if !allow_revoked && !entry.is_valid_url.load(Ordering::Acquire) {
491                log::warn!("Refusing to grant token for revoked blob url: {file_id:?}");
492                return FileTokenCheck::ShouldFail;
493            }
494            let token = Uuid::new_v4();
495            entry.outstanding_tokens.insert(token);
496            return FileTokenCheck::Required(token);
497        }
498        FileTokenCheck::ShouldFail
499    }
500
501    fn insert(&self, id: Uuid, entry: FileStoreEntry) {
502        self.entries.write().insert(id, entry);
503    }
504
505    fn remove(&self, id: &Uuid) {
506        self.entries.write().remove(id);
507    }
508
509    fn inc_ref(&self, id: &Uuid, origin_in: &ImmutableOrigin) -> Result<(), BlobURLStoreError> {
510        match self.entries.read().get(id) {
511            Some(entry) => {
512                if entry.origin == *origin_in {
513                    entry.refs.fetch_add(1, Ordering::Relaxed);
514                    Ok(())
515                } else {
516                    Err(BlobURLStoreError::InvalidOrigin)
517                }
518            },
519            None => Err(BlobURLStoreError::InvalidFileID),
520        }
521    }
522
523    fn add_sliced_url_entry(
524        &self,
525        parent_id: Uuid,
526        rel_pos: RelativePos,
527        sender: GenericSender<Result<Uuid, BlobURLStoreError>>,
528        origin_in: ImmutableOrigin,
529    ) {
530        match self.inc_ref(&parent_id, &origin_in) {
531            Ok(_) => {
532                let new_id = Uuid::new_v4();
533                self.insert(
534                    new_id,
535                    FileStoreEntry {
536                        origin: origin_in,
537                        file_impl: FileImpl::Sliced(parent_id, rel_pos),
538                        refs: AtomicUsize::new(1),
539                        // Valid here since AddSlicedURLEntry implies URL creation
540                        // from a BlobImpl::Sliced
541                        is_valid_url: AtomicBool::new(true),
542                        outstanding_tokens: Default::default(),
543                    },
544                );
545
546                // We assume that the returned id will be held by BlobImpl::File
547                let _ = sender.send(Ok(new_id));
548            },
549            Err(e) => {
550                let _ = sender.send(Err(e));
551            },
552        }
553    }
554
555    async fn select_files(
556        &self,
557        control_id: EmbedderControlId,
558        file_picker_request: FilePickerRequest,
559        embedder_proxy: GenericEmbedderProxy<NetToEmbedderMsg>,
560    ) -> EmbedderControlResponse {
561        let (sender, receiver) = tokio::sync::oneshot::channel();
562
563        let origin = file_picker_request.origin.clone();
564        embedder_proxy.send(NetToEmbedderMsg::SelectFiles(
565            control_id,
566            file_picker_request,
567            sender,
568        ));
569
570        let paths = match receiver.await {
571            Ok(Some(result)) => result,
572            Ok(None) => {
573                return EmbedderControlResponse::FilePicker(None);
574            },
575            Err(error) => {
576                warn!("Failed to receive files from embedder ({:?}).", error);
577                return EmbedderControlResponse::FilePicker(None);
578            },
579        };
580
581        let mut files = Vec::with_capacity(paths.len());
582        let mut failed = false;
583        for path in paths {
584            if let Err(error) = self.create_entries(&path, origin.clone(), &mut files) {
585                failed = true;
586                warn!("Failed to create entries for selected path: {error:?}");
587            }
588        }
589
590        // From <https://w3c.github.io/webdriver/#dfn-element-send-keys>:
591        //
592        // > Step 8.5: Verify that each file given by the user exists. If any do not,
593        // > return error with error code invalid argument.
594        //
595        // WebDriver expects that if any of the files isn't found we don't select any files.
596        if failed {
597            for file in files.iter() {
598                self.remove(&file.id);
599            }
600            return EmbedderControlResponse::FilePicker(Some(Vec::new()));
601        }
602
603        EmbedderControlResponse::FilePicker(Some(files))
604    }
605
606    /// Appends the entries for `path`, expanding a directory into its files.
607    ///
608    /// <https://wicg.github.io/entries-api/#html-forms>
609    fn create_entries(
610        &self,
611        path: &Path,
612        origin: ImmutableOrigin,
613        files: &mut Vec<SelectedFile>,
614    ) -> Result<(), FileManagerThreadError> {
615        if !path.is_dir() {
616            files.push(self.create_entry(path, origin, None)?);
617            return Ok(());
618        }
619        let root_name = path
620            .file_name()
621            .ok_or(FileManagerThreadError::FileSystemError(
622                "Invalid filepath".to_string(),
623            ))?;
624        let entries = walk_directory(path);
625        files.reserve(entries.len());
626        for (path, relative_path) in entries {
627            // A relative path starts from, and includes, the selected directory.
628            let relative_path = Path::new(root_name).join(relative_path);
629            // Paths in the entries API always use "/" as separator.
630            let relative_path = relative_path.to_string_lossy().replace('\\', "/");
631            files.push(self.create_entry(&path, origin.clone(), Some(relative_path))?);
632        }
633        Ok(())
634    }
635
636    fn create_entry(
637        &self,
638        file_path: &Path,
639        origin: ImmutableOrigin,
640        relative_path: Option<String>,
641    ) -> Result<SelectedFile, FileManagerThreadError> {
642        use net_traits::filemanager_thread::FileManagerThreadError::FileSystemError;
643
644        let metadata = file_path
645            .metadata()
646            .map_err(|e| FileSystemError(e.to_string()))?;
647        let modified = metadata
648            .modified()
649            .map_err(|e| FileSystemError(e.to_string()))?;
650        let file_size = metadata.len();
651        let file_name = file_path
652            .file_name()
653            .ok_or(FileSystemError("Invalid filepath".to_string()))?;
654
655        let file_impl = FileImpl::MetaDataOnly(FileMetaData {
656            path: file_path.to_path_buf(),
657            size: file_size,
658        });
659
660        let id = Uuid::new_v4();
661
662        self.insert(
663            id,
664            FileStoreEntry {
665                origin,
666                file_impl,
667                refs: AtomicUsize::new(1),
668                // Invalid here since create_entry is called by file selection
669                is_valid_url: AtomicBool::new(false),
670                outstanding_tokens: Default::default(),
671            },
672        );
673
674        let filename_path = Path::new(file_name);
675        let type_string = match mime_guess::from_path(filename_path).first() {
676            Some(x) => format!("{}", x),
677            None => String::new(),
678        };
679
680        Ok(SelectedFile {
681            id,
682            filename: filename_path.to_path_buf(),
683            modified,
684            size: file_size,
685            type_string,
686            relative_path,
687        })
688    }
689
690    async fn get_blob_buf(
691        &self,
692        sender: &GenericCallback<FileManagerResult<ReadFileProgress>>,
693        id: &Uuid,
694        file_token: &FileTokenCheck,
695        origin_in: &ImmutableOrigin,
696        rel_pos: RelativePos,
697    ) -> Result<(), BlobURLStoreError> {
698        let file_impl = self.get_impl(id, file_token, origin_in)?;
699        match file_impl {
700            FileImpl::Memory(buf) => {
701                let range = rel_pos.to_abs_range(buf.size as usize);
702                let buf = BlobBuf {
703                    filename: None,
704                    type_string: buf.type_string,
705                    size: range.len() as u64,
706                    bytes: buf.bytes.index(range).to_vec(),
707                };
708
709                let _ = sender.send(Ok(ReadFileProgress::Meta(buf)));
710                let _ = sender.send(Ok(ReadFileProgress::EOF));
711
712                Ok(())
713            },
714            FileImpl::MetaDataOnly(metadata) => {
715                /* XXX: Snapshot state check (optional) https://w3c.github.io/FileAPI/#snapshot-state.
716                        Concretely, here we create another file, and this file might not
717                        has the same underlying file state (meta-info plus content) as the time
718                        create_entry is called.
719                */
720
721                let opt_filename = metadata
722                    .path
723                    .file_name()
724                    .and_then(|osstr| osstr.to_str())
725                    .map(|s| s.to_string());
726
727                let mime = mime_guess::from_path(&metadata.path).first();
728                let range = rel_pos.to_abs_range(metadata.size as usize);
729
730                let mut file = tokio::fs::File::open(&metadata.path)
731                    .await
732                    .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
733                let seeked_start = file
734                    .seek(SeekFrom::Start(range.start as u64))
735                    .await
736                    .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
737
738                if seeked_start == (range.start as u64) {
739                    let type_string = match mime {
740                        Some(x) => format!("{}", x),
741                        None => String::new(),
742                    };
743
744                    read_file_in_chunks(sender, file, range.len(), opt_filename, type_string).await;
745                    Ok(())
746                } else {
747                    Err(BlobURLStoreError::InvalidEntry)
748                }
749            },
750            FileImpl::Sliced(parent_id, inner_rel_pos) => {
751                // Next time we don't need to check validity since
752                // we have already done that for requesting URL if necessary
753                Box::pin(self.get_blob_buf(
754                    sender,
755                    &parent_id,
756                    file_token,
757                    origin_in,
758                    rel_pos.slice_inner(&inner_rel_pos),
759                ))
760                .await
761            },
762        }
763    }
764
765    // Convenient wrapper over get_blob_buf
766    async fn try_read_file(
767        &self,
768        sender: &GenericCallback<FileManagerResult<ReadFileProgress>>,
769        id: Uuid,
770        origin_in: ImmutableOrigin,
771    ) -> Result<(), BlobURLStoreError> {
772        self.get_blob_buf(
773            sender,
774            &id,
775            &FileTokenCheck::NotRequired,
776            &origin_in,
777            RelativePos::full_range(),
778        )
779        .await
780    }
781
782    fn dec_ref(&self, id: &Uuid, origin_in: &ImmutableOrigin) -> Result<(), BlobURLStoreError> {
783        let (do_remove, opt_parent_id) = match self.entries.read().get(id) {
784            Some(entry) => {
785                if entry.origin == *origin_in {
786                    let old_refs = entry.refs.fetch_sub(1, Ordering::Release);
787
788                    if old_refs > 1 {
789                        // not the last reference, no need to touch parent
790                        (false, None)
791                    } else {
792                        // last reference, and if it has a reference to parent id
793                        // dec_ref on parent later if necessary
794                        let is_valid = entry.is_valid_url.load(Ordering::Acquire);
795
796                        // Check if no fetch has acquired a token for this file.
797                        let no_outstanding_tokens = entry.outstanding_tokens.is_empty();
798
799                        // Can we remove this file?
800                        let do_remove = !is_valid && no_outstanding_tokens;
801
802                        if let FileImpl::Sliced(ref parent_id, _) = entry.file_impl {
803                            (do_remove, Some(*parent_id))
804                        } else {
805                            (do_remove, None)
806                        }
807                    }
808                } else {
809                    return Err(BlobURLStoreError::InvalidOrigin);
810                }
811            },
812            None => return Err(BlobURLStoreError::InvalidFileID),
813        };
814
815        // Trigger removing if its last reference is gone and it is
816        // not a part of a valid Blob URL
817        if do_remove {
818            atomic::fence(Ordering::Acquire);
819            self.remove(id);
820
821            if let Some(parent_id) = opt_parent_id {
822                return self.dec_ref(&parent_id, origin_in);
823            }
824        }
825
826        Ok(())
827    }
828
829    fn promote_memory(
830        &self,
831        id: Uuid,
832        blob_buf: BlobBuf,
833        set_valid: bool,
834        origin: ImmutableOrigin,
835    ) {
836        self.insert(
837            id,
838            FileStoreEntry {
839                origin,
840                file_impl: FileImpl::Memory(blob_buf),
841                refs: AtomicUsize::new(1),
842                is_valid_url: AtomicBool::new(set_valid),
843                outstanding_tokens: Default::default(),
844            },
845        );
846    }
847
848    fn set_blob_url_validity(
849        &self,
850        validity: bool,
851        id: &Uuid,
852        origin_in: &ImmutableOrigin,
853    ) -> Result<(), BlobURLStoreError> {
854        let (do_remove, opt_parent_id, res) = match self.entries.read().get(id) {
855            Some(entry) => {
856                if entry.origin == *origin_in {
857                    entry.is_valid_url.store(validity, Ordering::Release);
858
859                    if !validity {
860                        // Check if it is the last possible reference
861                        // since refs only accounts for blob id holders
862                        // and store entry id holders
863                        let zero_refs = entry.refs.load(Ordering::Acquire) == 0;
864
865                        // Check if no fetch has acquired a token for this file.
866                        let no_outstanding_tokens = entry.outstanding_tokens.is_empty();
867
868                        // Can we remove this file?
869                        let do_remove = zero_refs && no_outstanding_tokens;
870
871                        if let FileImpl::Sliced(ref parent_id, _) = entry.file_impl {
872                            (do_remove, Some(*parent_id), Ok(()))
873                        } else {
874                            (do_remove, None, Ok(()))
875                        }
876                    } else {
877                        (false, None, Ok(()))
878                    }
879                } else {
880                    (false, None, Err(BlobURLStoreError::InvalidOrigin))
881                }
882            },
883            None => (false, None, Err(BlobURLStoreError::InvalidFileID)),
884        };
885
886        if do_remove {
887            atomic::fence(Ordering::Acquire);
888            self.remove(id);
889
890            if let Some(parent_id) = opt_parent_id {
891                return self.dec_ref(&parent_id, origin_in);
892            }
893        }
894        res
895    }
896}
897
898async fn read_file_in_chunks(
899    sender: &GenericCallback<FileManagerResult<ReadFileProgress>>,
900    mut file: tokio::fs::File,
901    size: usize,
902    opt_filename: Option<String>,
903    type_string: String,
904) {
905    // First chunk
906    let mut buf = vec![0; FILE_CHUNK_SIZE];
907    match file.read(&mut buf).await {
908        Ok(n) => {
909            buf.truncate(n);
910            let blob_buf = BlobBuf {
911                filename: opt_filename,
912                type_string,
913                size: size as u64,
914                bytes: buf,
915            };
916            let _ = sender.send(Ok(ReadFileProgress::Meta(blob_buf)));
917        },
918        Err(e) => {
919            let _ = sender.send(Err(FileManagerThreadError::FileSystemError(e.to_string())));
920            return;
921        },
922    }
923
924    // Send the remaining chunks
925    loop {
926        let mut buf = vec![0; FILE_CHUNK_SIZE];
927        match file.read(&mut buf).await {
928            Ok(0) => {
929                let _ = sender.send(Ok(ReadFileProgress::EOF));
930                return;
931            },
932            Ok(n) => {
933                buf.truncate(n);
934                let _ = sender.send(Ok(ReadFileProgress::Partial(buf)));
935            },
936            Err(e) => {
937                let _ = sender.send(Err(FileManagerThreadError::FileSystemError(e.to_string())));
938                return;
939            },
940        }
941    }
942}
943
944fn set_blob_response_headers(
945    headers: &mut HeaderMap,
946    content_length: u64,
947    mime: Mime,
948    content_range: Option<ContentRange>,
949) {
950    headers.typed_insert(ContentLength(content_length));
951    if let Some(content_range) = content_range {
952        headers.typed_insert(content_range);
953    }
954    headers.typed_insert(ContentType::from(mime));
955}
956
957/// Returns `(absolute path, path relative to root)` for each regular file under `root`.
958fn walk_directory(root: &Path) -> Vec<(PathBuf, PathBuf)> {
959    let mut files = Vec::new();
960    for entry in WalkDir::new(root) {
961        let entry = match entry {
962            Ok(entry) => entry,
963            Err(error) => {
964                warn!("Skipping an unreadable entry while walking a directory: {error}");
965                continue;
966            },
967        };
968        if entry.file_type().is_file() {
969            let relative_path = entry
970                .path()
971                .strip_prefix(root)
972                .expect("walked entries are under root");
973            files.push((entry.path().to_path_buf(), relative_path.to_path_buf()));
974        }
975    }
976    files
977}