actix_files/
service.rs

1use std::{fmt, io, ops::Deref, path::PathBuf, rc::Rc};
2
3use actix_web::{
4    body::BoxBody,
5    dev::{self, Service, ServiceRequest, ServiceResponse},
6    error::Error,
7    guard::Guard,
8    http::{header, Method},
9    HttpResponse,
10};
11use futures_core::future::LocalBoxFuture;
12
13use crate::{
14    named, Directory, DirectoryRenderer, FilesError, HttpService, MimeOverride, NamedFile,
15    PathBufWrap, PathFilter,
16};
17
18/// Assembled file serving service.
19#[derive(Clone)]
20pub struct FilesService(pub(crate) Rc<FilesServiceInner>);
21
22impl Deref for FilesService {
23    type Target = FilesServiceInner;
24
25    fn deref(&self) -> &Self::Target {
26        &self.0
27    }
28}
29
30pub struct FilesServiceInner {
31    pub(crate) directory: PathBuf,
32    pub(crate) index: Option<String>,
33    pub(crate) show_index: bool,
34    pub(crate) redirect_to_slash: bool,
35    pub(crate) default: Option<HttpService>,
36    pub(crate) renderer: Rc<DirectoryRenderer>,
37    pub(crate) mime_override: Option<Rc<MimeOverride>>,
38    pub(crate) path_filter: Option<Rc<PathFilter>>,
39    pub(crate) file_flags: named::Flags,
40    pub(crate) guards: Option<Rc<dyn Guard>>,
41    pub(crate) hidden_files: bool,
42    pub(crate) size_threshold: u64,
43}
44
45impl fmt::Debug for FilesServiceInner {
46    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
47        f.write_str("FilesServiceInner")
48    }
49}
50
51impl FilesService {
52    async fn handle_err(
53        &self,
54        err: io::Error,
55        req: ServiceRequest,
56    ) -> Result<ServiceResponse, Error> {
57        log::debug!("error handling {}: {}", req.path(), err);
58
59        if let Some(ref default) = self.default {
60            default.call(req).await
61        } else {
62            Ok(req.error_response(err))
63        }
64    }
65
66    fn serve_named_file(&self, req: ServiceRequest, mut named_file: NamedFile) -> ServiceResponse {
67        if let Some(ref mime_override) = self.mime_override {
68            let new_disposition = mime_override(&named_file.content_type.type_());
69            named_file.content_disposition.disposition = new_disposition;
70        }
71        named_file.flags = self.file_flags;
72
73        let (req, _) = req.into_parts();
74        let res = named_file
75            .read_mode_threshold(self.size_threshold)
76            .into_response(&req);
77        ServiceResponse::new(req, res)
78    }
79
80    fn show_index(&self, req: ServiceRequest, path: PathBuf) -> ServiceResponse {
81        let dir = Directory::new(self.directory.clone(), path);
82
83        let (req, _) = req.into_parts();
84
85        (self.renderer)(&dir, &req).unwrap_or_else(|err| ServiceResponse::from_err(err, req))
86    }
87}
88
89impl fmt::Debug for FilesService {
90    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
91        f.write_str("FilesService")
92    }
93}
94
95impl Service<ServiceRequest> for FilesService {
96    type Response = ServiceResponse<BoxBody>;
97    type Error = Error;
98    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
99
100    dev::always_ready!();
101
102    fn call(&self, req: ServiceRequest) -> Self::Future {
103        let is_method_valid = if let Some(guard) = &self.guards {
104            // execute user defined guards
105            (**guard).check(&req.guard_ctx())
106        } else {
107            // default behavior
108            matches!(*req.method(), Method::HEAD | Method::GET)
109        };
110
111        let this = self.clone();
112
113        Box::pin(async move {
114            if !is_method_valid {
115                return Ok(req.into_response(
116                    HttpResponse::MethodNotAllowed()
117                        .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
118                        .body("Request did not meet this resource's requirements."),
119                ));
120            }
121
122            let path_on_disk =
123                match PathBufWrap::parse_path(req.match_info().unprocessed(), this.hidden_files) {
124                    Ok(item) => item,
125                    Err(err) => return Ok(req.error_response(err)),
126                };
127
128            if let Some(filter) = &this.path_filter {
129                if !filter(path_on_disk.as_ref(), req.head()) {
130                    if let Some(ref default) = this.default {
131                        return default.call(req).await;
132                    } else {
133                        return Ok(req.into_response(HttpResponse::NotFound().finish()));
134                    }
135                }
136            }
137
138            // full file path
139            let path = this.directory.join(&path_on_disk);
140            if let Err(err) = path.canonicalize() {
141                return this.handle_err(err, req).await;
142            }
143
144            if path.is_dir() {
145                if this.redirect_to_slash
146                    && !req.path().ends_with('/')
147                    && (this.index.is_some() || this.show_index)
148                {
149                    let redirect_to = format!("{}/", req.path());
150
151                    return Ok(req.into_response(
152                        HttpResponse::Found()
153                            .insert_header((header::LOCATION, redirect_to))
154                            .finish(),
155                    ));
156                }
157
158                match this.index {
159                    Some(ref index) => {
160                        let named_path = path.join(index);
161                        match NamedFile::open_async(named_path).await {
162                            Ok(named_file) => Ok(this.serve_named_file(req, named_file)),
163                            Err(_) if this.show_index => Ok(this.show_index(req, path)),
164                            Err(err) => this.handle_err(err, req).await,
165                        }
166                    }
167                    None if this.show_index => Ok(this.show_index(req, path)),
168                    None => Ok(ServiceResponse::from_err(
169                        FilesError::IsDirectory,
170                        req.into_parts().0,
171                    )),
172                }
173            } else {
174                match NamedFile::open_async(&path).await {
175                    Ok(named_file) => Ok(this.serve_named_file(req, named_file)),
176                    Err(err) => this.handle_err(err, req).await,
177                }
178            }
179        })
180    }
181}
actix_files/service.rs

actix_files/
service.rs
