Skip to content
1        10        20        30        40        50        60        70        80        901use std::{2    collections::HashMap,3    future,4    io::{self, SeekFrom},5    path::{Component, Path, PathBuf},6    pin::Pin,7    sync::{Arc, Mutex},8    time::SystemTime,9};1011use bytes::{Buf, Bytes};12use cap_std::{ambient_authority, fs::Dir};13use dav_server::{14    davpath::DavPath,15    fs::{16        DavDirEntry, DavFile, DavFileSystem, DavMetaData, DavProp, FsError, FsFuture, FsResult,17        FsStream, OpenOptions, ReadDirMeta,18    },19};20use futures_util::stream;21use http::StatusCode;22use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};2324#[derive(Clone)]25pub struct RootFs {26    root: Arc<Dir>,27    dead_properties: Arc<Mutex<HashMap<PathBuf, HashMap<String, DavProp>>>>,28}2930impl RootFs {31    pub fn open(path: &Path) -> io::Result<Self> {32        Ok(Self {33            root: Arc::new(Dir::open_ambient_dir(path, ambient_authority())?),34            dead_properties: Arc::new(Mutex::new(HashMap::new())),35        })36    }3738    pub fn is_accessible(&self) -> bool {39        self.root40            .dir_metadata()41            .map(|metadata| metadata.is_dir())42            .unwrap_or(false)43    }4445    fn relative_path(path: &DavPath) -> FsResult<PathBuf> {46        let relative = path.as_rel_ospath();47        if relative.as_os_str().is_empty() {48            return Ok(PathBuf::from("."));49        }50        if relative.to_string_lossy().contains('\0')51            || relative.components().any(|component| {52                matches!(53                    component,54                    Component::ParentDir | Component::RootDir | Component::Prefix(_)55                )56            })57        {58            return Err(FsError::Forbidden);59        }60        Ok(relative.to_path_buf())61    }6263    fn reject_root(path: &Path) -> FsResult<()> {64        if path == Path::new(".") || path.as_os_str().is_empty() {65            Err(FsError::Forbidden)66        } else {67            Ok(())68        }69    }7071    fn property_key(property: &DavProp) -> String {72        format!(73            "{}\0{}",74            property.namespace.as_deref().unwrap_or_default(),75            property.name76        )77    }78}7980fn blocking<T, F>(operation: F) -> FsFuture<'static, T>81where82    T: Send + 'static,83    F: FnOnce() -> io::Result<T> + Send + 'static,84{85    Box::pin(async move {86        tokio::task::spawn_blocking(operation)87            .await88            .map_err(|_| FsError::GeneralFailure)?89            .map_err(FsError::from)90    })91}9293fn failed<T: Send + 'static>(error: FsError) -> FsFuture<'static, T> {94    Box::pin(future::ready(Err(error)))95}9697impl DavFileSystem for RootFs {98    fn metadata<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, Box<dyn DavMetaData>> {99        let relative = match Self::relative_path(path) {100            Ok(relative) => relative,101            Err(error) => return failed(error),102        };103        let root = Arc::clone(&self.root);104        Box::pin(async move {105            let metadata = blocking(move || root.metadata(relative)).await?;106            Ok(Box::new(RootMetadata::from_cap(metadata)) as Box<dyn DavMetaData>)107        })108    }109110    fn symlink_metadata<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, Box<dyn DavMetaData>> {111        let relative = match Self::relative_path(path) {112            Ok(relative) => relative,113            Err(error) => return failed(error),114        };115        let root = Arc::clone(&self.root);116        Box::pin(async move {117            let metadata = blocking(move || root.symlink_metadata(relative)).await?;118            Ok(Box::new(RootMetadata::from_cap(metadata)) as Box<dyn DavMetaData>)119        })120    }121122    fn read_dir<'a>(123        &'a self,124        path: &'a DavPath,125        meta: ReadDirMeta,126    ) -> FsFuture<'a, FsStream<Box<dyn DavDirEntry>>> {127        let relative = match Self::relative_path(path) {128            Ok(relative) => relative,129            Err(error) => return failed(error),130        };131        let root = Arc::clone(&self.root);132        Box::pin(async move {133            let entries = blocking(move || {134                let mut entries = Vec::new();135                for entry in root.read_dir(&relative)? {136                    let entry = entry?;137                    let name = entry.file_name();138                    entries.push(Box::new(RootDirEntry {139                        root: Arc::clone(&root),140                        path: relative.join(&name),141                        name: name.as_encoded_bytes().to_vec(),142                        meta,143                    }) as Box<dyn DavDirEntry>);144                }145                Ok(entries)146            })147            .await?;148            let stream = stream::iter(entries.into_iter().map(Ok::<_, FsError>));149            Ok(Box::pin(stream) as FsStream<Box<dyn DavDirEntry>>)150        })151    }152153    fn open<'a>(154        &'a self,155        path: &'a DavPath,156        options: OpenOptions,157    ) -> FsFuture<'a, Box<dyn DavFile>> {158        let relative = match Self::relative_path(path) {159            Ok(relative) => relative,160            Err(error) => return failed(error),161        };162        let root = Arc::clone(&self.root);163        Box::pin(async move {164            let file = blocking(move || {165                let mut open_options = cap_std::fs::OpenOptions::new();166                open_options167                    .read(options.read)168                    .write(options.write)169                    .append(options.append)170                    .truncate(options.truncate)171                    .create(options.create)172                    .create_new(options.create_new);173                let file = root.open_with(relative, &open_options)?;174                if let Some(size) = options.size {175                    file.set_len(size)?;176                }177                Ok(file.into_std())178            })179            .await?;180            Ok(Box::new(RootDavFile {181                file: tokio::fs::File::from_std(file),182            }) as Box<dyn DavFile>)183        })184    }185186    fn create_dir<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, ()> {187        let relative = match Self::relative_path(path).and_then(|path| {188            Self::reject_root(&path)?;189            Ok(path)190        }) {191            Ok(relative) => relative,192            Err(error) => return failed(error),193        };194        let root = Arc::clone(&self.root);195        blocking(move || root.create_dir(relative))196    }197198    fn remove_dir<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, ()> {199        let relative = match Self::relative_path(path).and_then(|path| {200            Self::reject_root(&path)?;201            Ok(path)202        }) {203            Ok(relative) => relative,204            Err(error) => return failed(error),205        };206        let root = Arc::clone(&self.root);207        let dead_properties = Arc::clone(&self.dead_properties);208        Box::pin(async move {209            let path_for_io = relative.clone();210            blocking(move || root.remove_dir(path_for_io)).await?;211            dead_properties212                .lock()213                .map_err(|_| FsError::GeneralFailure)?214                .remove(&relative);215            Ok(())216        })217    }218219    fn remove_file<'a>(&'a self, path: &'a DavPath) -> FsFuture<'a, ()> {220        let relative = match Self::relative_path(path).and_then(|path| {221            Self::reject_root(&path)?;222            Ok(path)223        }) {224            Ok(relative) => relative,225            Err(error) => return failed(error),226        };227        let root = Arc::clone(&self.root);228        let dead_properties = Arc::clone(&self.dead_properties);229        Box::pin(async move {230            let path_for_io = relative.clone();231            blocking(move || root.remove_file(path_for_io)).await?;232            dead_properties233                .lock()234                .map_err(|_| FsError::GeneralFailure)?235                .remove(&relative);236            Ok(())237        })238    }239240    fn rename<'a>(&'a self, from: &'a DavPath, to: &'a DavPath) -> FsFuture<'a, ()> {241        let from = match Self::relative_path(from).and_then(|path| {242            Self::reject_root(&path)?;243            Ok(path)244        }) {245            Ok(path) => path,246            Err(error) => return failed(error),247        };248        let to = match Self::relative_path(to).and_then(|path| {249            Self::reject_root(&path)?;250            Ok(path)251        }) {252            Ok(path) => path,253            Err(error) => return failed(error),254        };255        let root = Arc::clone(&self.root);256        let dead_properties = Arc::clone(&self.dead_properties);257        Box::pin(async move {258            let from_for_io = from.clone();259            let to_for_io = to.clone();260            blocking(move || root.rename(from_for_io, &root, to_for_io)).await?;261            let mut properties = dead_properties262                .lock()263                .map_err(|_| FsError::GeneralFailure)?;264            if let Some(properties_for_file) = properties.remove(&from) {265                properties.insert(to, properties_for_file);266            }267            Ok(())268        })269    }270271    fn copy<'a>(&'a self, from: &'a DavPath, to: &'a DavPath) -> FsFuture<'a, ()> {272        let from = match Self::relative_path(from).and_then(|path| {273            Self::reject_root(&path)?;274            Ok(path)275        }) {276            Ok(path) => path,277            Err(error) => return failed(error),278        };279        let to = match Self::relative_path(to).and_then(|path| {280            Self::reject_root(&path)?;281            Ok(path)282        }) {283            Ok(path) => path,284            Err(error) => return failed(error),285        };286        let root = Arc::clone(&self.root);287        let dead_properties = Arc::clone(&self.dead_properties);288        Box::pin(async move {289            let from_for_io = from.clone();290            let to_for_io = to.clone();291            blocking(move || root.copy(&from_for_io, &root, &to_for_io).map(|_| ())).await?;292            let mut properties = dead_properties293                .lock()294                .map_err(|_| FsError::GeneralFailure)?;295            if let Some(properties_for_file) = properties.get(&from).cloned() {296                properties.insert(to, properties_for_file);297            }298            Ok(())299        })300    }301302    fn have_props<'a>(303        &'a self,304        _path: &'a DavPath,305    ) -> Pin<Box<dyn std::future::Future<Output = bool> + Send + 'a>> {306        Box::pin(future::ready(true))307    }308309    fn patch_props<'a>(310        &'a self,311        path: &'a DavPath,312        patch: Vec<(bool, DavProp)>,313    ) -> FsFuture<'a, Vec<(StatusCode, DavProp)>> {314        let relative = match Self::relative_path(path) {315            Ok(relative) => relative,316            Err(error) => return failed(error),317        };318        Box::pin(async move {319            let mut all_properties = self320                .dead_properties321                .lock()322                .map_err(|_| FsError::GeneralFailure)?;323            let properties = all_properties.entry(relative).or_default();324            let mut result = Vec::with_capacity(patch.len());325            for (set, property) in patch {326                let key = Self::property_key(&property);327                let status = if set {328                    properties.insert(key, property.clone());329                    StatusCode::OK330                } else if properties.remove(&key).is_some() {331                    StatusCode::OK332                } else {333                    StatusCode::NOT_FOUND334                };335                result.push((status, property));336            }337            Ok(result)338        })339    }340341    fn get_props<'a>(&'a self, path: &'a DavPath, do_content: bool) -> FsFuture<'a, Vec<DavProp>> {342        let relative = match Self::relative_path(path) {343            Ok(relative) => relative,344            Err(error) => return failed(error),345        };346        Box::pin(async move {347            let all_properties = self348                .dead_properties349                .lock()350                .map_err(|_| FsError::GeneralFailure)?;351            let mut properties = all_properties352                .get(&relative)353                .map(|properties| properties.values().cloned().collect::<Vec<_>>())354                .unwrap_or_default();355            if !do_content {356                for property in &mut properties {357                    property.xml = None;358                }359            }360            Ok(properties)361        })362    }363364    fn get_prop<'a>(&'a self, path: &'a DavPath, property: DavProp) -> FsFuture<'a, Vec<u8>> {365        let relative = match Self::relative_path(path) {366            Ok(relative) => relative,367            Err(error) => return failed(error),368        };369        Box::pin(async move {370            let all_properties = self371                .dead_properties372                .lock()373                .map_err(|_| FsError::GeneralFailure)?;374            all_properties375                .get(&relative)376                .and_then(|properties| properties.get(&Self::property_key(&property)))377                .and_then(|property| property.xml.clone())378                .ok_or(FsError::NotFound)379        })380    }381}382383#[derive(Debug)]384struct RootDirEntry {385    root: Arc<Dir>,386    path: PathBuf,387    name: Vec<u8>,388    meta: ReadDirMeta,389}390391impl DavDirEntry for RootDirEntry {392    fn name(&self) -> Vec<u8> {393        self.name.clone()394    }395396    fn metadata(&self) -> FsFuture<'_, Box<dyn DavMetaData>> {397        let root = Arc::clone(&self.root);398        let path = self.path.clone();399        let use_symlink_metadata = self.meta != ReadDirMeta::Data;400        Box::pin(async move {401            let metadata = blocking(move || {402                if use_symlink_metadata {403                    root.symlink_metadata(path)404                } else {405                    root.metadata(path)406                }407            })408            .await?;409            Ok(Box::new(RootMetadata::from_cap(metadata)) as Box<dyn DavMetaData>)410        })411    }412}413414#[derive(Clone, Debug)]415struct RootMetadata {416    len: u64,417    modified: FsResult<SystemTime>,418    is_dir: bool,419    is_symlink: bool,420}421422impl RootMetadata {423    fn from_cap(metadata: cap_std::fs::Metadata) -> Self {424        Self {425            len: metadata.len(),426            modified: metadata427                .modified()428                .map(cap_std::time::SystemTime::into_std)429                .map_err(FsError::from),430            is_dir: metadata.is_dir(),431            is_symlink: metadata.is_symlink(),432        }433    }434435    fn from_std(metadata: std::fs::Metadata) -> Self {436        Self {437            len: metadata.len(),438            modified: metadata.modified().map_err(FsError::from),439            is_dir: metadata.is_dir(),440            is_symlink: metadata.file_type().is_symlink(),441        }442    }443}444445impl DavMetaData for RootMetadata {446    fn len(&self) -> u64 {447        self.len448    }449450    fn modified(&self) -> FsResult<SystemTime> {451        self.modified452    }453454    fn is_dir(&self) -> bool {455        self.is_dir456    }457458    fn is_symlink(&self) -> bool {459        self.is_symlink460    }461}462463#[derive(Debug)]464struct RootDavFile {465    file: tokio::fs::File,466}467468impl DavFile for RootDavFile {469    fn metadata(&mut self) -> FsFuture<'_, Box<dyn DavMetaData>> {470        Box::pin(async move {471            let metadata = self.file.metadata().await.map_err(FsError::from)?;472            Ok(Box::new(RootMetadata::from_std(metadata)) as Box<dyn DavMetaData>)473        })474    }475476    fn write_buf(&mut self, mut buf: Box<dyn Buf + Send>) -> FsFuture<'_, ()> {477        Box::pin(async move {478            while buf.has_remaining() {479                let chunk = buf.chunk();480                self.file.write_all(chunk).await.map_err(FsError::from)?;481                let written = chunk.len();482                buf.advance(written);483            }484            Ok(())485        })486    }487488    fn write_bytes(&mut self, buf: Bytes) -> FsFuture<'_, ()> {489        Box::pin(async move { self.file.write_all(&buf).await.map_err(FsError::from) })490    }491492    fn read_bytes(&mut self, count: usize) -> FsFuture<'_, Bytes> {493        Box::pin(async move {494            let mut buf = vec![0; count];495            let read = self.file.read(&mut buf).await.map_err(FsError::from)?;496            buf.truncate(read);497            Ok(Bytes::from(buf))498        })499    }500501    fn seek(&mut self, pos: SeekFrom) -> FsFuture<'_, u64> {502        Box::pin(async move { self.file.seek(pos).await.map_err(FsError::from) })503    }504505    fn flush(&mut self) -> FsFuture<'_, ()> {506        Box::pin(async move { self.file.flush().await.map_err(FsError::from) })507    }508}509510#[cfg(test)]511mod tests {512    use super::*;513514    #[test]515    fn rejects_parent_components() {516        assert!(DavPath::new("/../outside").is_err());517        assert!(DavPath::new("/%2e%2e/outside").is_err());518    }519520    #[test]521    fn maps_virtual_root_to_dot_and_protects_it_from_mutation() {522        let path = DavPath::new("/").expect("valid root DAV path");523        let relative = RootFs::relative_path(&path).expect("root path");524        assert_eq!(relative, PathBuf::from("."));525        assert_eq!(RootFs::reject_root(&relative), Err(FsError::Forbidden));526    }527}